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

  24. import java.io.File;
  25. import java.util.ArrayList;
  26. import java.util.Iterator;
  27. import java.util.List;

  29. import org.openspcoop2.core.config.AccessoRegistro;
  30. import org.openspcoop2.core.config.AccessoRegistroRegistro;
  31. import org.openspcoop2.core.config.Attachments;
  32. import org.openspcoop2.core.config.Cache;
  33. import org.openspcoop2.core.config.Configurazione;
  34. import org.openspcoop2.core.config.Connettore;
  35. import org.openspcoop2.core.config.CorrelazioneApplicativa;
  36. import org.openspcoop2.core.config.CorrelazioneApplicativaElemento;
  37. import org.openspcoop2.core.config.CorrelazioneApplicativaRisposta;
  38. import org.openspcoop2.core.config.CorrelazioneApplicativaRispostaElemento;
  39. import org.openspcoop2.core.config.Credenziali;
  40. import org.openspcoop2.core.config.Dump;
  41. import org.openspcoop2.core.config.GestioneErrore;
  42. import org.openspcoop2.core.config.GestioneErroreCodiceTrasporto;
  43. import org.openspcoop2.core.config.GestioneErroreSoapFault;
  44. import org.openspcoop2.core.config.IndirizzoRisposta;
  45. import org.openspcoop2.core.config.InoltroBusteNonRiscontrate;
  46. import org.openspcoop2.core.config.IntegrationManager;
  47. import org.openspcoop2.core.config.InvocazioneCredenziali;
  48. import org.openspcoop2.core.config.InvocazionePorta;
  49. import org.openspcoop2.core.config.InvocazionePortaGestioneErrore;
  50. import org.openspcoop2.core.config.InvocazioneServizio;
  51. import org.openspcoop2.core.config.MessageSecurity;
  52. import org.openspcoop2.core.config.MessageSecurityFlow;
  53. import org.openspcoop2.core.config.MessageSecurityFlowParameter;
  54. import org.openspcoop2.core.config.MessaggiDiagnostici;
  55. import org.openspcoop2.core.config.MtomProcessor;
  56. import org.openspcoop2.core.config.MtomProcessorFlow;
  57. import org.openspcoop2.core.config.MtomProcessorFlowParameter;
  58. import org.openspcoop2.core.config.OpenspcoopAppender;
  59. import org.openspcoop2.core.config.PortaApplicativa;
  60. import org.openspcoop2.core.config.PortaApplicativaAzione;
  61. import org.openspcoop2.core.config.PortaApplicativaServizio;
  62. import org.openspcoop2.core.config.PortaApplicativaServizioApplicativo;
  63. import org.openspcoop2.core.config.PortaApplicativaSoggettoVirtuale;
  64. import org.openspcoop2.core.config.PortaDelegata;
  65. import org.openspcoop2.core.config.PortaDelegataAzione;
  66. import org.openspcoop2.core.config.PortaDelegataServizio;
  67. import org.openspcoop2.core.config.PortaDelegataServizioApplicativo;
  68. import org.openspcoop2.core.config.PortaDelegataSoggettoErogatore;
  69. import org.openspcoop2.core.config.Property;
  70. import org.openspcoop2.core.config.Proprieta;
  71. import org.openspcoop2.core.config.RispostaAsincrona;
  72. import org.openspcoop2.core.config.Risposte;
  73. import org.openspcoop2.core.config.Route;
  74. import org.openspcoop2.core.config.RouteGateway;
  75. import org.openspcoop2.core.config.RouteRegistro;
  76. import org.openspcoop2.core.config.RoutingTable;
  77. import org.openspcoop2.core.config.RoutingTableDefault;
  78. import org.openspcoop2.core.config.RoutingTableDestinazione;
  79. import org.openspcoop2.core.config.ServizioApplicativo;
  80. import org.openspcoop2.core.config.Soggetto;
  81. import org.openspcoop2.core.config.StatoServiziPdd;
  82. import org.openspcoop2.core.config.StatoServiziPddIntegrationManager;
  83. import org.openspcoop2.core.config.StatoServiziPddPortaApplicativa;
  84. import org.openspcoop2.core.config.StatoServiziPddPortaDelegata;
  85. import org.openspcoop2.core.config.TipoFiltroAbilitazioneServizi;
  86. import org.openspcoop2.core.config.Tracciamento;
  87. import org.openspcoop2.core.config.ValidazioneBuste;
  88. import org.openspcoop2.core.config.ValidazioneContenutiApplicativi;
  89. import org.openspcoop2.core.config.constants.AlgoritmoCache;
  90. import org.openspcoop2.core.config.constants.CorrelazioneApplicativaGestioneIdentificazioneFallita;
  91. import org.openspcoop2.core.config.constants.CorrelazioneApplicativaRichiestaIdentificazione;
  92. import org.openspcoop2.core.config.constants.CorrelazioneApplicativaRispostaIdentificazione;
  93. import org.openspcoop2.core.config.constants.CostantiConfigurazione;
  94. import org.openspcoop2.core.config.constants.CredenzialeTipo;
  95. import org.openspcoop2.core.config.constants.FaultIntegrazioneTipo;
  96. import org.openspcoop2.core.config.constants.GestioneErroreComportamento;
  97. import org.openspcoop2.core.config.constants.InvocazioneServizioTipoAutenticazione;
  98. import org.openspcoop2.core.config.constants.PortaApplicativaAzioneIdentificazione;
  99. import org.openspcoop2.core.config.constants.PortaDelegataAzioneIdentificazione;
  100. import org.openspcoop2.core.config.constants.RegistroTipo;
  101. import org.openspcoop2.core.config.constants.Severita;
  102. import org.openspcoop2.core.config.constants.StatoFunzionalita;
  103. import org.openspcoop2.core.config.constants.StatoFunzionalitaConWarning;
  104. import org.openspcoop2.core.config.constants.TipoConnessioneRisposte;
  105. import org.openspcoop2.core.config.constants.ValidazioneBusteTipoControllo;
  106. import org.openspcoop2.core.config.constants.ValidazioneContenutiApplicativiTipo;
  107. import org.openspcoop2.core.constants.CostantiConnettori;
  108. import org.openspcoop2.core.constants.CostantiDB;
  109. import org.openspcoop2.core.constants.TipiConnettore;
  110. import org.openspcoop2.utils.certificate.CertificateUtils;
  111. import org.openspcoop2.utils.certificate.PrincipalType;
  112. import org.openspcoop2.utils.regexp.RegExpUtilities;
  113. import org.openspcoop2.utils.regexp.RegularExpressionEngine;
  114. import org.slf4j.Logger;


  117. /**
  118.  * Validazione Semantica
  119.  * 
  120.  * @author $Author$
  121.  * @version $Rev$, $Date$
  122.  */
  123. public class ValidazioneSemantica {

  125.     /** ConfigurazionePdD */
  126.     private org.openspcoop2.core.config.Openspcoop2 configurazione = null;
  127.     /** Lista in cui scrivo le anomalie riscontrate */
  128.     private List<String> errori = new ArrayList<>();
  129.     /** Logger */
  130.     private Logger log = null;
  131.     /** Indicazione se deve essere validata la configurazione */
  132.     private boolean validazioneConfigurazione = false;

  134.     /** Lista di tipi di connettori validi */
  135.     private List<String> tipoConnettori = new ArrayList<>();
  136.     /** Lista dei tipi di connettori ammessi */
  137.     private String getTipoConnettori(){
  138.         StringBuilder bf = new StringBuilder();
  139.         for(int i=0; i<this.tipoConnettori.size(); i++){
  140.             if(i>0)
  141.                 bf.append(",");
  142.             bf.append(this.tipoConnettori.get(i));
  143.         }
  144.         return bf.toString();
  145.     }

  147.     /** Lista di tipi di soggetti validi */
  148.     private List<String> tipoSoggetti = new ArrayList<>();
  149.     /** Lista dei tipi di soggetti ammessi */
  150.     private String getTipoSoggetti(){
  151.         StringBuilder bf = new StringBuilder();
  152.         for(int i=0; i<this.tipoSoggetti.size(); i++){
  153.             if(i>0)
  154.                 bf.append(",");
  155.             bf.append(this.tipoSoggetti.get(i));
  156.         }
  157.         return bf.toString();
  158.     }

  160.     /** Lista di tipi di servizi (soap) validi */
  161.     private List<String> tipoServiziSoap = new ArrayList<>();
  162.     /** Lista dei tipi di servizi ammessi */
  163.     private String getTipoServiziSoap(){  
  164.         StringBuilder bf = new StringBuilder();
  165.         for(int i=0; i<this.tipoServiziSoap.size(); i++){
  166.             if(i>0)
  167.                 bf.append(",");
  168.             bf.append(this.tipoServiziSoap.get(i));
  169.         }
  170.         return bf.toString();
  171.     }
  172.     
  173.     /** Lista di tipi di servizi (rest) validi */
  174.     private List<String> tipoServiziRest = new ArrayList<>();
  175.     /** Lista dei tipi di servizi ammessi */
  176.     private String getTipoServiziRest(){
  177.         StringBuilder bf = new StringBuilder();
  178.         for(int i=0; i<this.tipoServiziRest.size(); i++){
  179.             if(i>0)
  180.                 bf.append(",");
  181.             bf.append(this.tipoServiziRest.get(i));
  182.         }
  183.         return bf.toString();
  184.     }
  185.     
  186.     private String getTipoServizi(){
  187.         StringBuilder bf = new StringBuilder();
  188.         
  189.         String soap = getTipoServiziSoap();
  190.         if(soap!=null && !"".equals(soap)){
  191.             bf.append(soap);
  192.         }
  193.         
  194.         String rest = getTipoServiziRest();
  195.         if(rest!=null && !"".equals(rest)){
  196.             if(bf.length()>0)
  197.                 bf.append(",");
  198.             bf.append(rest);
  199.         }
  200.         
  201.         return bf.toString();
  202.     }
  203.     
  204.     /** Lista di tipi di msg diagnostici appender validi */
  205.     private List<String> tipoMsgDiagnosticiAppender = new ArrayList<>();
  206.     /** Lista dei tipi di msg diagnostici appender ammessi */
  207.     private String getTipoMsgDiagnosticiAppender(){
  208.         StringBuilder bf = new StringBuilder();
  209.         for(int i=0; i<this.tipoMsgDiagnosticiAppender.size(); i++){
  210.             if(i>0)
  211.                 bf.append(",");
  212.             bf.append(this.tipoMsgDiagnosticiAppender.get(i));
  213.         }
  214.         return bf.toString();
  215.     }
  216.     
  217.     /** Lista di tipi di tracciamento appender validi */
  218.     private List<String> tipoTracciamentoAppender = new ArrayList<>();
  219.     /** Lista dei tipi di tracciamento appender ammessi */
  220.     private String getTipoTracciamentoAppender(){
  221.         StringBuilder bf = new StringBuilder();
  222.         for(int i=0; i<this.tipoTracciamentoAppender.size(); i++){
  223.             if(i>0)
  224.                 bf.append(",");
  225.             bf.append(this.tipoTracciamentoAppender.get(i));
  226.         }
  227.         return bf.toString();
  228.     }
  229.     
  230.     /** Lista di tipi di dump appender validi */
  231.     private List<String> tipoDumpAppender = new ArrayList<>();
  232.     /** Lista dei tipi di dump appender ammessi */
  233.     private String getTipoDumpAppender(){
  234.         StringBuilder bf = new StringBuilder();
  235.         for(int i=0; i<this.tipoDumpAppender.size(); i++){
  236.             if(i>0)
  237.                 bf.append(",");
  238.             bf.append(this.tipoDumpAppender.get(i));
  239.         }
  240.         return bf.toString();
  241.     }

  243.     /** Lista di tipi di autenticazione porta delegata validi */
  244.     private List<String> tipoAutenticazionePortaDelegata = new ArrayList<>();
  245.     /** Lista dei tipi di autenticazione porta delegata ammessi */
  246.     private String getTipoAutenticazionePortaDelegata(){
  247.         StringBuilder bf = new StringBuilder();
  248.         for(int i=0; i<this.tipoAutenticazionePortaDelegata.size(); i++){
  249.             if(i>0)
  250.                 bf.append(",");
  251.             bf.append(this.tipoAutenticazionePortaDelegata.get(i));
  252.         }
  253.         return bf.toString();
  254.     }
  255.     
  256.     /** Lista di tipi di autenticazione porta applicativa validi */
  257.     private List<String> tipoAutenticazionePortaApplicativa = new ArrayList<>();
  258.     /** Lista dei tipi di autenticazione porta applicativa ammessi */
  259.     private String getTipoAutenticazionePortaApplicativa(){
  260.         StringBuilder bf = new StringBuilder();
  261.         for(int i=0; i<this.tipoAutenticazionePortaApplicativa.size(); i++){
  262.             if(i>0)
  263.                 bf.append(",");
  264.             bf.append(this.tipoAutenticazionePortaApplicativa.get(i));
  265.         }
  266.         return bf.toString();
  267.     }
  268.     
  269.     /** Lista di tipi di autorizzazione porta delegata validi */
  270.     private List<String> tipoAutorizzazionePortaDelegata = new ArrayList<>();
  271.     /** Lista dei tipi di autorizzazione porta delegata ammessi */
  272.     private String getTipoAutorizzazionePortaDelegata(){
  273.         StringBuilder bf = new StringBuilder();
  274.         for(int i=0; i<this.tipoAutorizzazionePortaDelegata.size(); i++){
  275.             if(i>0)
  276.                 bf.append(",");
  277.             bf.append(this.tipoAutorizzazionePortaDelegata.get(i));
  278.         }
  279.         return bf.toString();
  280.     }
  281.     
  282.     /** Lista di tipi di autorizzazione porta applicativa validi */
  283.     private List<String> tipoAutorizzazionePortaApplicativa = new ArrayList<>();
  284.     /** Lista dei tipi di autorizzazione porta applicativa ammessi */
  285.     private String getTipoAutorizzazionePortaApplicativa(){
  286.         StringBuilder bf = new StringBuilder();
  287.         for(int i=0; i<this.tipoAutorizzazionePortaApplicativa.size(); i++){
  288.             if(i>0)
  289.                 bf.append(",");
  290.             bf.append(this.tipoAutorizzazionePortaApplicativa.get(i));
  291.         }
  292.         return bf.toString();
  293.     }
  294.     
  295.     /** Lista di tipi di autorizzazione per contenuto porta delegata validi */
  296.     private List<String> tipoAutorizzazioneContenutoPortaDelegata = new ArrayList<>();
  297.     /** Lista dei tipi di autorizzazione per contenuto porta delegata  ammessi */
  298.     private String getTipoAutorizzazioneContenutoPortaDelegata(){
  299.         StringBuilder bf = new StringBuilder();
  300.         for(int i=0; i<this.tipoAutorizzazioneContenutoPortaDelegata.size(); i++){
  301.             if(i>0)
  302.                 bf.append(",");
  303.             bf.append(this.tipoAutorizzazioneContenutoPortaDelegata.get(i));
  304.         }
  305.         return bf.toString();
  306.     }
  307.     
  308.     /** Lista di tipi di autorizzazione per contenuto porta applicativa validi */
  309.     private List<String> tipoAutorizzazioneContenutoPortaApplicativa = new ArrayList<>();
  310.     /** Lista dei tipi di autorizzazione per contenuto porta applicativa  ammessi */
  311.     private String getTipoAutorizzazioneContenutoPortaApplicativa(){
  312.         StringBuilder bf = new StringBuilder();
  313.         for(int i=0; i<this.tipoAutorizzazioneContenutoPortaApplicativa.size(); i++){
  314.             if(i>0)
  315.                 bf.append(",");
  316.             bf.append(this.tipoAutorizzazioneContenutoPortaApplicativa.get(i));
  317.         }
  318.         return bf.toString();
  319.     }
  320.     
  321.     /** Lista di tipi di integrazionePD validi */
  322.     private List<String> tipoIntegrazionePD = new ArrayList<>();
  323.     /** Lista dei tipi di integrazionePD ammessi */
  324.     private String getTipoIntegrazionePD(){
  325.         StringBuilder bf = new StringBuilder();
  326.         for(int i=0; i<this.tipoIntegrazionePD.size(); i++){
  327.             if(i>0)
  328.                 bf.append(",");
  329.             bf.append(this.tipoIntegrazionePD.get(i));
  330.         }
  331.         return bf.toString();
  332.     }
  333.     
  334.     /** Lista di tipi di integrazionePA validi */
  335.     private List<String> tipoIntegrazionePA = new ArrayList<>();
  336.     /** Lista dei tipi di integrazionePA ammessi */
  337.     private String getTipoIntegrazionePA(){
  338.         StringBuilder bf = new StringBuilder();
  339.         for(int i=0; i<this.tipoIntegrazionePA.size(); i++){
  340.             if(i>0)
  341.                 bf.append(",");
  342.             bf.append(this.tipoIntegrazionePA.get(i));
  343.         }
  344.         return bf.toString();
  345.     }
  346.     
  347.     

  349.     public ValidazioneSemantica(org.openspcoop2.core.config.Openspcoop2 configurazione,
  350.             String[]tipoConnettori,String[]tipoSoggetti,String[]tipoServiziSoap,String[]tipoServiziRest,
  351.             String[]tipoMsgDiagnosticiAppender,String[]tipoTracciamentoAppender,String[]tipoDumpAppender,
  352.             String[]tipoAutenticazionePortaDelegata,String[]tipoAutenticazionePortaApplicativa,
  353.             String[]tipoAutorizzazionePortaDelegata,String[]tipoAutorizzazionePortaApplicativa,
  354.             String[]tipoAutorizzazioneContenutoPortaDelegata,String[]tipoAutorizzazioneContenutoPortaApplicativa,
  355.             String[]tipoIntegrazionePD,String[]tipoIntegrazionePA,
  356.             boolean validazioneConfigurazione,Logger log) throws DriverConfigurazioneException{
  357.         this.configurazione = configurazione;
  358.         this.log = log;
  359.         this.validazioneConfigurazione = validazioneConfigurazione;
  360.         if(tipoConnettori!=null && tipoConnettori.length>0 ){
  361.             for(int i=0; i<tipoConnettori.length; i++){
  362.                 this.tipoConnettori.add(tipoConnettori[i]);
  363.             }
  364.         }else{
  365.             throw new DriverConfigurazioneException("Tipo di connettori ammissibili non definiti");
  366.         }
  367.         if(tipoSoggetti!=null && tipoSoggetti.length>0 ){
  368.             for(int i=0; i<tipoSoggetti.length; i++){
  369.                 this.tipoSoggetti.add(tipoSoggetti[i]);
  370.             }
  371.         }else{
  372.             throw new DriverConfigurazioneException("Tipo di soggetti ammissibili non definiti");
  373.         }
  374.         boolean tipiSoapNonEsistenti = false;
  375.         if(tipoServiziSoap!=null && tipoServiziSoap.length>0 ){
  376.             for(int i=0; i<tipoServiziSoap.length; i++){
  377.                 this.tipoServiziSoap.add(tipoServiziSoap[i]);
  378.             }
  379.         }else{
  380.             tipiSoapNonEsistenti = true;
  381.         }
  382.         boolean tipiRestNonEsistenti = false;
  383.         if(tipoServiziRest!=null && tipoServiziRest.length>0 ){
  384.             for(int i=0; i<tipoServiziRest.length; i++){
  385.                 this.tipoServiziRest.add(tipoServiziRest[i]);
  386.             }
  387.         }else{
  388.             tipiRestNonEsistenti = true;            
  389.         }
  390.         if(tipiSoapNonEsistenti && tipiRestNonEsistenti){
  391.             throw new DriverConfigurazioneException("Non sono stati configurati tipo di servizi ne per il service binding Soap ne per Rest");
  392.         }
  393.         if(tipoMsgDiagnosticiAppender!=null && tipoMsgDiagnosticiAppender.length>0 ){
  394.             for(int i=0; i<tipoMsgDiagnosticiAppender.length; i++){
  395.                 this.tipoMsgDiagnosticiAppender.add(tipoMsgDiagnosticiAppender[i]);
  396.             }
  397.         }else{
  398.             throw new DriverConfigurazioneException("Tipo di appender ammissibili per i msg diagnostici non definiti");
  399.         }
  400.         if(tipoTracciamentoAppender!=null && tipoTracciamentoAppender.length>0 ){
  401.             for(int i=0; i<tipoTracciamentoAppender.length; i++){
  402.                 this.tipoTracciamentoAppender.add(tipoTracciamentoAppender[i]);
  403.             }
  404.         }else{
  405.             throw new DriverConfigurazioneException("Tipo di appender ammissibili per le traccie non definiti");
  406.         }
  407.         if(tipoDumpAppender!=null && tipoDumpAppender.length>0 ){
  408.             for(int i=0; i<tipoDumpAppender.length; i++){
  409.                 this.tipoDumpAppender.add(tipoDumpAppender[i]);
  410.             }
  411.         }else{
  412.             throw new DriverConfigurazioneException("Tipo di appender ammissibili per il dump non definiti");
  413.         }
  414.         if(tipoAutenticazionePortaDelegata!=null && tipoAutenticazionePortaDelegata.length>0 ){
  415.             for(int i=0; i<tipoAutenticazionePortaDelegata.length; i++){
  416.                 this.tipoAutenticazionePortaDelegata.add(tipoAutenticazionePortaDelegata[i]);
  417.             }
  418.         }else{
  419.             throw new DriverConfigurazioneException("Tipo di processi di autenticazione porta delegata ammissibili non definiti");
  420.         }
  421.         if(tipoAutenticazionePortaApplicativa!=null && tipoAutenticazionePortaApplicativa.length>0 ){
  422.             for(int i=0; i<tipoAutenticazionePortaApplicativa.length; i++){
  423.                 this.tipoAutenticazionePortaApplicativa.add(tipoAutenticazionePortaApplicativa[i]);
  424.             }
  425.         }else{
  426.             throw new DriverConfigurazioneException("Tipo di processi di autenticazione porta applicativa ammissibili non definiti");
  427.         }
  428.         if(tipoAutorizzazionePortaDelegata!=null && tipoAutorizzazionePortaDelegata.length>0 ){
  429.             for(int i=0; i<tipoAutorizzazionePortaDelegata.length; i++){
  430.                 this.tipoAutorizzazionePortaDelegata.add(tipoAutorizzazionePortaDelegata[i]);
  431.             }
  432.         }else{
  433.             throw new DriverConfigurazioneException("Tipo di processi di autorizzazione porta delegata ammissibili non definiti");
  434.         }
  435.         if(tipoAutorizzazionePortaApplicativa!=null && tipoAutorizzazionePortaApplicativa.length>0 ){
  436.             for(int i=0; i<tipoAutorizzazionePortaApplicativa.length; i++){
  437.                 this.tipoAutorizzazionePortaApplicativa.add(tipoAutorizzazionePortaApplicativa[i]);
  438.             }
  439.         }else{
  440.             throw new DriverConfigurazioneException("Tipo di processi di autorizzazione porta applicativa ammissibili non definiti");
  441.         }
  442.         if(tipoAutorizzazioneContenutoPortaDelegata!=null && tipoAutorizzazioneContenutoPortaDelegata.length>0 ){
  443.             for(int i=0; i<tipoAutorizzazioneContenutoPortaDelegata.length; i++){
  444.                 this.tipoAutorizzazioneContenutoPortaDelegata.add(tipoAutorizzazioneContenutoPortaDelegata[i]);
  445.             }
  446.         }else{
  447.             throw new DriverConfigurazioneException("Tipo di processi di autorizzazione contenuto porta delegata ammissibili non definiti");
  448.         }
  449.         if(tipoAutorizzazioneContenutoPortaApplicativa!=null && tipoAutorizzazioneContenutoPortaApplicativa.length>0 ){
  450.             for(int i=0; i<tipoAutorizzazioneContenutoPortaApplicativa.length; i++){
  451.                 this.tipoAutorizzazioneContenutoPortaApplicativa.add(tipoAutorizzazioneContenutoPortaApplicativa[i]);
  452.             }
  453.         }else{
  454.             throw new DriverConfigurazioneException("Tipo di processi di autorizzazione contenuto porta applicativa ammissibili non definiti");
  455.         }
  456.         if(tipoIntegrazionePD!=null && tipoIntegrazionePD.length>0 ){
  457.             for(int i=0; i<tipoIntegrazionePD.length; i++){
  458.                 this.tipoIntegrazionePD.add(tipoIntegrazionePD[i]);
  459.             }
  460.         }else{
  461.             throw new DriverConfigurazioneException("Tipo di integrazione lato PortaDelegata ammissibili non definiti");
  462.         }
  463.         if(tipoIntegrazionePA!=null && tipoIntegrazionePA.length>0 ){
  464.             for(int i=0; i<tipoIntegrazionePA.length; i++){
  465.                 this.tipoIntegrazionePA.add(tipoIntegrazionePA[i]);
  466.             }
  467.         }else{
  468.             throw new DriverConfigurazioneException("Tipo di integrazione lato PortaApplicativa ammissibili non definiti");
  469.         }
  470.     }
  471.     public ValidazioneSemantica(org.openspcoop2.core.config.Openspcoop2 configurazione,
  472.             String[]tipoConnettori,String[]tipoSoggetti,String[]tipoServiziSoap,String[]tipoServiziRest,
  473.             String[]tipoMsgDiagnosticiAppender,String[]tipoTracciamentoAppender,String[]tipoDumpAppender,
  474.             String[]tipoAutenticazionePortaDelegata,String[]tipoAutenticazionePortaApplicativa,
  475.             String[]tipoAutorizzazionePortaDelegata,String[]tipoAutorizzazionePortaApplicativa,
  476.             String[]tipoAutorizzazioneContenutoPortaDelegata,String[]tipoAutorizzazioneContenutoPortaApplicativa,
  477.             String[]tipoIntegrazionePD,String[]tipoIntegrazionePA,
  478.             boolean validazioneConfigurazione) throws DriverConfigurazioneException{
  479.         this(configurazione,tipoConnettori,tipoSoggetti,tipoServiziSoap,tipoServiziRest,tipoMsgDiagnosticiAppender,tipoTracciamentoAppender,tipoDumpAppender,
  480.                 tipoAutenticazionePortaDelegata,tipoAutenticazionePortaApplicativa,
  481.                 tipoAutorizzazionePortaDelegata,tipoAutorizzazionePortaApplicativa,
  482.                 tipoAutorizzazioneContenutoPortaDelegata,tipoAutorizzazioneContenutoPortaApplicativa,
  483.                 tipoIntegrazionePD,tipoIntegrazionePA,
  484.                 validazioneConfigurazione,null);
  485.     }

  487.     private void printMsg(String msg){
  488.         if(this.log == null){
  489.             printMsg(msg);
  490.         }else{
  491.             this.log.debug(msg);
  492.         }
  493.     }


  496.     public void validazioneSemantica(boolean showIDOggettiAnalizzati) throws DriverConfigurazioneException {

  498.         if(showIDOggettiAnalizzati)
  499.             printMsg("\n\n------------------------------------Soggetti("+this.configurazione.sizeSoggettoList()+")-----------------------------------------------------");

  501.         // soggetto
  502.         for(int i=0; i<this.configurazione.sizeSoggettoList();i++){
  503.             Soggetto sogg = this.configurazione.getSoggetto(i);
  504.             if(showIDOggettiAnalizzati)
  505.                 printMsg("Soggetto: "+sogg.getTipo()+"/"+sogg.getNome());
  506.             validaSoggetto(sogg,showIDOggettiAnalizzati);
  507.         }


  510.         if(this.validazioneConfigurazione){
  511.             if(showIDOggettiAnalizzati)
  512.                 printMsg("\n\n------------------------------------Configurazione-----------------------------------------------------");
  513.     
  514.             // Configurazione
  515.             this.validaConfigurazione(this.configurazione.getConfigurazione());
  516.         }


  519.         if(showIDOggettiAnalizzati)
  520.             printMsg("\n\n-----------------------------------------------------------------------------------------");

  522.         // Se è stata trovata almeno un'anomalia, lancio un'eccezione
  523.         if (!this.errori.isEmpty()) {
  524.             StringBuilder stringB = new StringBuilder().append("\n");
  525.             Iterator<String> itE = this.errori.iterator();
  526.             while (itE.hasNext())
  527.                 stringB.append(itE.next()).append("\n");
  528.             throw new DriverConfigurazioneException(stringB.toString());
  529.         }
  530.     }


  533.     private  void validaSoggetto(Soggetto sogg,boolean showIDOggettiAnalizzati) throws DriverConfigurazioneException {

  535.         // required
  536.         if(sogg.getNome()==null){
  537.             this.errori.add("Esiste un soggetto senza nome");
  538.             return;
  539.         }
  540.         if(sogg.getTipo()==null){
  541.             this.errori.add("Esiste un soggetto senza tipo");
  542.             return;
  543.         }
  544.         
  545.         // porte delegate
  546.         for(int j =0; j<sogg.sizePortaDelegataList(); j++){
  547.             PortaDelegata pd = sogg.getPortaDelegata(j);
  548.             if(showIDOggettiAnalizzati)
  549.                 printMsg("\tPorta Delegata: "+pd.getNome());
  550.             validaPortaDelegata(pd, sogg);
  551.         }

  553.         // porte applicative
  554.         for(int j =0; j<sogg.sizePortaApplicativaList(); j++){
  555.             PortaApplicativa pa = sogg.getPortaApplicativa(j);
  556.             if(showIDOggettiAnalizzati)
  557.                 printMsg("\tPortaApplicativa: "+pa.getNome());
  558.             validaPortaApplicativa(pa, sogg);
  559.         }

  561.         // servizi applicativi
  562.         for(int j =0; j<sogg.sizeServizioApplicativoList(); j++){
  563.             ServizioApplicativo sa = sogg.getServizioApplicativo(j);
  564.             if(showIDOggettiAnalizzati)
  565.                 printMsg("\tServizioApplicativo: "+sa.getNome());
  566.             validaServizioApplicativo(sa, sogg);
  567.         }

  569.         // connettori presenti nella root del soggetto
  570.         for(int j=0; j<sogg.sizeConnettoreList();j++){
  571.             Connettore connettore = sogg.getConnettore(j);
  572.             if(showIDOggettiAnalizzati)
  573.                 printMsg("\tConnettore definito nella root del soggetto: "+connettore.getNome());
  574.             this.validaConnettore(connettore, null, sogg);
  575.         }
  576.         
  577.         // 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()
  578.         if(this.tipoSoggetti.contains(sogg.getTipo())==false){
  579.             this.errori.add("Il tipo del soggetto "+sogg.getTipo()+"/"+sogg.getNome()+" non è valido (Tipi utilizzabili: "+this.getTipoSoggetti()+")");
  580.         }

  582.         // Nome del soggetto
  583.         try{
  584.             if (!RegularExpressionEngine.isMatch(sogg.getNome(),"^[0-9A-Za-z]+$")) {
  585.                 this.errori.add("Il nome del soggetto "+sogg.getTipo()+"/"+sogg.getNome()+" dev'essere formato solo caratteri e cifre");
  586.             }
  587.         }catch(Exception e){
  588.             throw new DriverConfigurazioneException("Errore durante l'analisi tramite espressione regolare del soggetto "+sogg.getTipo()+"/"+sogg.getNome()+": "+e.getMessage(),e);
  589.         }

  591.         // ogni soggetto identificato come coppia tipo/nome, deve essere univoco
  592.         int numS = 0;
  593.         for(int j=0; j<this.configurazione.sizeSoggettoList();j++){
  594.             Soggetto tmpSogg = this.configurazione.getSoggetto(j);
  595.             if (sogg.getNome().equals(tmpSogg.getNome()) && sogg.getTipo().equals(tmpSogg.getTipo()))
  596.                 numS++;
  597.         }
  598.         if (numS > 1)
  599.             this.errori.add("Non può esistere più di un soggetto con nome "+sogg.getNome()+" e tipo "+sogg.getTipo());


  602.         // Controlla che esista SOLO un soggetto che contiene router=true
  603.         if (sogg.getRouter()) {
  604.             int numR = 0;
  605.             for(int j=0; j<this.configurazione.sizeSoggettoList();j++){
  606.                 Soggetto tmpS = this.configurazione.getSoggetto(j);
  607.                 if (tmpS.getRouter())
  608.                     numR++;
  609.             }
  610.             if (numR > 1)
  611.                 this.errori.add("Non può esistere più di un soggetto abilitato alla funzione di Router");
  612.         }
  613.         
  614.         // Controllo che eventuali PdUrlPrefixRewriter o PaUrlPrefixRewriter rispettino l'espressione regolare: [A-Za-z]+:\/\/(.*)
  615.         try{
  616.             if(sogg.getPdUrlPrefixRewriter()!=null){
  617.                 if(RegularExpressionEngine.isMatch(sogg.getPdUrlPrefixRewriter(), "[A-Za-z]+:\\/\\/(.*)")==false){
  618.                     this.errori.add("La funzione PdUrlPrefixRewriter contiene un valore errato che non rispetta l'espressione "+"[A-Za-z]+:\\/\\/(.*)");
  619.                 }
  620.             }
  621.             if(sogg.getPaUrlPrefixRewriter()!=null){
  622.                 if(RegularExpressionEngine.isMatch(sogg.getPaUrlPrefixRewriter(), "[A-Za-z]+:\\/\\/(.*)")==false){
  623.                     this.errori.add("La funzione PaUrlPrefixRewriter contiene un valore errato che non rispetta l'espressione "+"[A-Za-z]+:\\/\\/(.*)");
  624.                 }
  625.             }
  626.         }catch(Exception e){
  627.             throw new DriverConfigurazioneException(e);
  628.         }
  629.     }


  632.     private  void validaPortaDelegata(PortaDelegata pd, Soggetto sogg) throws DriverConfigurazioneException {
  633.         
  634.         if(pd.getNome()==null){
  635.             this.errori.add("Il soggetto ["+sogg.getTipo()+"/"+sogg.getNome()+"] posside una porta delegata che non contiene la definizione del nome");
  636.             return;
  637.         }
  638.         
  639.         String nomePorta = pd.getNome();
  640.         String idPortaDelegata = "("+sogg.getTipo()+"/"+sogg.getNome()+") "+nomePorta;
  641.         
  642.         // La porta delegata viene identificata dal nome.
  643.         // Una volta identificata la sua stringa di identificazione DEVE essere univoca tra tutte le porte delegate di TUTTA la configurazione 
  644.         // (e non solo tra quelle del soggetto proprietario)
  645.         int numPD = 0;
  646.         List<String> pdTrovate = new ArrayList<>();
  647.         for(int j=0; j<this.configurazione.sizeSoggettoList();j++){
  648.             Soggetto s = this.configurazione.getSoggetto(j);
  649.             for(int k =0; k<s.sizePortaDelegataList(); k++){
  650.                 PortaDelegata tmpPd = s.getPortaDelegata(k);
  651.                 String tmpNomePorta = tmpPd.getNome();
  652.                 if (nomePorta.equals(tmpNomePorta)){
  653.                     numPD++;
  654.                     pdTrovate.add("("+s.getTipo()+"/"+s.getNome()+") "+tmpPd.getNome());
  655.                 }
  656.             }
  657.         }
  658.         if (numPD > 1)
  659.             this.errori.add("Non può esistere più di una porta delegata con nome "+nomePorta+". Sono state identificate le seguenti porte delegate: "+pdTrovate);

  661.         
  662.         // Il soggetto erogatore deve essere definito. Il tipo e' obbligatorio.
  663.         // Il nome DEVE essere presente solo se identificazione='static'.
  664.         // Il pattern DEVE essere definito solo se identificazione='urlBased' o 'contentBased'.
  665.         if (pd.getSoggettoErogatore() == null)
  666.             this.errori.add("La porta delegata "+idPortaDelegata+" non contiene la definizione del soggetto erogatore");
  667.         else {
  668.             PortaDelegataSoggettoErogatore pdsse = pd.getSoggettoErogatore();
  669.             
  670.             // Tipo
  671.             if (pdsse.getTipo() == null){
  672.                 this.errori.add("Il soggetto erogatore della porta delegata "+idPortaDelegata+" non contiene la definizione del tipo.");
  673.             }
  674.             else if(this.tipoSoggetti.contains(pdsse.getTipo())==false){
  675.                 this.errori.add("Il tipo del soggetto erogatore della porta delegata "+idPortaDelegata+" non è valido (Tipi utilizzabili: "+this.getTipoSoggetti()+")");
  676.             }
  677.             
  678.             // Nome
  679.             if (pdsse.getNome() == null){
  680.                 this.errori.add("Il soggetto erogatore della porta delegata "+idPortaDelegata+" non contiene la definizione del nome");
  681.             }           
  682.         }

  684.         // Il servizio deve essere definito. Il tipo e' obbligatorio.
  685.         // Il nome DEVE essere presente solo se identificazione='static'.
  686.         // Il pattern DEVE essere definito solo se identificazione='urlBased' o 'contentBased'.
  687.         if (pd.getServizio() == null)
  688.             this.errori.add("La porta delegata "+idPortaDelegata+" non contiene la definizione del servizio");
  689.         else {
  690.             PortaDelegataServizio pds = pd.getServizio();
  691.             
  692.             // Tipo
  693.             if (pds.getTipo() == null){
  694.                 this.errori.add("Il servizio della porta delegata "+idPortaDelegata+" non contiene la definizione del tipo.");
  695.             }
  696.             else if(this.tipoServiziSoap.contains(pds.getTipo())==false && this.tipoServiziRest.contains(pds.getTipo())==false){
  697.                 this.errori.add("Il tipo del servizio della porta delegata "+idPortaDelegata+" non è valido (Tipi utilizzabili: "+this.getTipoServizi()+")");
  698.             }
  699.             
  700.             // Nome
  701.             if (pds.getNome() == null){
  702.                 this.errori.add("Il servizio della porta delegata "+idPortaDelegata+" non contiene la definizione del nome");
  703.             }       
  704.         }

  706.         
  707.         // L'azione e' opzionale. Se presente:
  708.         // Il nome DEVE essere presente solo se identificazione='static'.
  709.         // Il pattern DEVE essere definito solo se identificazione='urlBased' o 'contentBased'.
  710.         if (pd.getAzione() != null){
  711.             PortaDelegataAzione pda = pd.getAzione();
  712.             
  713.             // XSD: identificazione: static, urlBased, contentBased, inputBased e soapActionBased
  714.             PortaDelegataAzioneIdentificazione identificazione = pda.getIdentificazione();
  715.             if ((identificazione != null) && !identificazione.equals(CostantiConfigurazione.PORTA_DELEGATA_AZIONE_STATIC) && 
  716.                     !identificazione.equals(CostantiConfigurazione.PORTA_DELEGATA_AZIONE_URL_BASED) && 
  717.                     !identificazione.equals(CostantiConfigurazione.PORTA_DELEGATA_AZIONE_CONTENT_BASED) &&
  718.                     !identificazione.equals(CostantiConfigurazione.PORTA_DELEGATA_AZIONE_HEADER_BASED) && 
  719.                     !identificazione.equals(CostantiConfigurazione.PORTA_DELEGATA_AZIONE_INPUT_BASED) && 
  720.                     !identificazione.equals(CostantiConfigurazione.PORTA_DELEGATA_AZIONE_SOAP_ACTION_BASED) && 
  721.                     !identificazione.equals(CostantiConfigurazione.PORTA_DELEGATA_AZIONE_WSDL_BASED) && 
  722.                     !identificazione.equals(CostantiConfigurazione.PORTA_DELEGATA_AZIONE_DELEGATED_BY)){
  723.                 this.errori.add("La modalita d'identificazione dell'azione della porta delegata "+idPortaDelegata+" deve assumere uno dei seguente valori: "+
  724.                         CostantiConfigurazione.PORTA_DELEGATA_AZIONE_STATIC+", "+
  725.                         CostantiConfigurazione.PORTA_DELEGATA_AZIONE_URL_BASED+", "+
  726.                         CostantiConfigurazione.PORTA_DELEGATA_AZIONE_CONTENT_BASED+", "+
  727.                         CostantiConfigurazione.PORTA_DELEGATA_AZIONE_HEADER_BASED+" o "+
  728.                         CostantiConfigurazione.PORTA_DELEGATA_AZIONE_INPUT_BASED+" o "+
  729.                         CostantiConfigurazione.PORTA_DELEGATA_AZIONE_SOAP_ACTION_BASED+" o "+
  730.                         CostantiConfigurazione.PORTA_DELEGATA_AZIONE_WSDL_BASED+" o "+
  731.                         CostantiConfigurazione.PORTA_DELEGATA_AZIONE_DELEGATED_BY);
  732.             }
  733.             if(identificazione==null){
  734.                 identificazione = CostantiConfigurazione.PORTA_DELEGATA_AZIONE_STATIC;
  735.             }
  736.             
  737.             if(CostantiConfigurazione.PORTA_DELEGATA_AZIONE_STATIC.equals(identificazione)){
  738.                 if (pda.getNome() == null)
  739.                     this.errori.add("L'azione della porta delegata "+idPortaDelegata+" non contiene la definizione del nome, nonostante la modalita' di identificazione sia "+identificazione);
  740.             }
  741.             else if(CostantiConfigurazione.PORTA_DELEGATA_AZIONE_URL_BASED.equals(identificazione) || 
  742.                     CostantiConfigurazione.PORTA_DELEGATA_AZIONE_CONTENT_BASED.equals(identificazione) || 
  743.                     CostantiConfigurazione.PORTA_DELEGATA_AZIONE_HEADER_BASED.equals(identificazione)){
  744.                 if (pda.getPattern() == null)
  745.                     this.errori.add("L'azione della porta delegata "+idPortaDelegata+" non contiene la definizione del pattern, nonostante la modalita' di identificazione sia "+identificazione);
  746.             }
  747.             else if(CostantiConfigurazione.PORTA_DELEGATA_AZIONE_DELEGATED_BY.equals(identificazione)){
  748.                 if (pda.getNomePortaDelegante() == null)
  749.                     this.errori.add("L'azione della porta delegata "+idPortaDelegata+" non contiene la definizione del nome della porta delegante, nonostante la modalita' di identificazione sia "+identificazione);
  750.             }
  751.         }
  752.         
  753.     
  754.         // Check processo di autenticazione della porta delegata
  755.         String autenticazione = CredenzialeTipo.SSL.toString();
  756.         if(pd.getAutenticazione()!=null){
  757.             autenticazione = pd.getAutenticazione();
  758.             if(this.tipoAutenticazionePortaDelegata.contains(pd.getAutenticazione())==false){
  759.                 this.errori.add("Alla porta delegata "+idPortaDelegata+" e' stato associato un processo di autenticazione ["+pd.getAutenticazione()+"] non valido; tipi conosciuti: "+this.getTipoAutenticazionePortaDelegata()); 
  760.             }
  761.         }
  762.         
  763.         // Autorizzazione
  764.         String autorizzazione = CostantiConfigurazione.AUTORIZZAZIONE_AUTHENTICATED;
  765.         if(pd.getAutorizzazione()!=null){
  766.             autorizzazione = pd.getAutorizzazione();
  767.             if(this.tipoAutorizzazionePortaDelegata.contains(pd.getAutorizzazione())==false){
  768.                 this.errori.add("Alla porta delegata "+idPortaDelegata+" e' stato associato un processo di autorizzazione ["+pd.getAutorizzazione()+"] non valido; tipi conosciuti: "+this.getTipoAutorizzazionePortaDelegata()); 
  769.             }
  770.         }
  771.         
  772.         if(autorizzazione!=null){
  773.             if(autorizzazione.toLowerCase().contains(CostantiConfigurazione.AUTORIZZAZIONE_AUTHENTICATED) &&
  774.                     autorizzazione.toLowerCase().contains(CostantiConfigurazione.AUTORIZZAZIONE_ROLES)){
  775.                 // Se e' definito un processo di autorizzazione che prevede sia autenticazione che ruoli l'autenticazione deve essere opzionale
  776.                 if(StatoFunzionalita.ABILITATO.equals(pd.getAutenticazioneOpzionale())==false){
  777.                     this.errori.add("Alla porta delegata "+idPortaDelegata+" e' stato associata un'autorizzazione '"+autorizzazione+"' che richiede una autenticazione dei servizi applicativi opzionali"); 
  778.                 }
  779.             }
  780.             if(autorizzazione.toLowerCase().contains("internal") || 
  781.                     (CostantiConfigurazione.AUTORIZZAZIONE_AUTHENTICATED.equals(autorizzazione))){
  782.                 // Se l'autorizzazione prevede una gestione dei ruoli interni, oppure è solamente basata sull'autenticazione dei chiamanti, 
  783.                 // una autenticazione DEVE essere presente e non deve essere opzionale
  784.                 if(CostantiConfigurazione.AUTENTICAZIONE_NONE.equals(autenticazione)){
  785.                     this.errori.add("Alla porta delegata "+idPortaDelegata+" e' stato associata un'autorizzazione '"+autorizzazione+"' che richiede una autenticazione obbligatoria dei servizi applicativi, autenticazione non impostata nella porta delegata"); 
  786.                 }
  787.                 if(StatoFunzionalita.ABILITATO.equals(pd.getAutenticazioneOpzionale())){
  788.                     if(autorizzazione.toLowerCase().contains("or")==false){
  789.                         this.errori.add("Alla porta delegata "+idPortaDelegata+" e' stato associata un'autorizzazione '"+autorizzazione+"' che richiede una autenticazione obbligatoria dei servizi applicativi, autenticazione impostata come opzionale nella porta delegata");
  790.                     }
  791.                 }
  792.             }
  793.         }

  795.         // Vincoli troppo forti nel caso di configurazione su console, la PdD non parte se la configurazione non e' stata ultimata.
  796. //      if(autorizzazione!=null && autorizzazione.contains(CostantiConfigurazione.AUTORIZZAZIONE_AUTHENTICATED)){
  797. //          if (pd.sizeServizioApplicativoList() == 0){
  798. //              this.errori.add("La porta delegata "+idPortaDelegata+" deve avere almeno un servizio applicativo associato poiche' lo richiede il tipo di autorizzazione indicato: "+autorizzazione);
  799. //          }
  800. //      }
  801. //      if(autorizzazione!=null && autorizzazione.toLowerCase().contains(CostantiConfigurazione.AUTORIZZAZIONE_ROLES.toLowerCase())){
  802. //          if (pd.getRuoli()==null || pd.getRuoli().sizeRuoloList() == 0){
  803. //              this.errori.add("La porta delegata "+idPortaDelegata+" deve avere almeno un ruolo associato poiche' lo richiede il tipo di autorizzazione indicato: "+autorizzazione);
  804. //          }
  805. //      }
  806.         
  807.         // Autorizzazione Contenuto
  808.         if(pd.getAutorizzazioneContenuto()!=null){
  809.             if(this.tipoAutorizzazioneContenutoPortaDelegata.contains(pd.getAutorizzazioneContenuto())==false){
  810.                 this.errori.add("Alla porta delegata "+idPortaDelegata+" e' stato associato un processo di autorizzazione contenuto ["+pd.getAutorizzazioneContenuto()+"] non valido; tipi conosciuti: "+this.getTipoAutorizzazioneContenutoPortaDelegata()); 
  811.             }
  812.         }
  813.         
  814.         // Check servizi applicativi
  815.         for(int i=0; i<pd.sizeServizioApplicativoList(); i++){
  816.             // Servizio Applicativo puo' avere solo meta informazioni
  817.             PortaDelegataServizioApplicativo pdSa = pd.getServizioApplicativo(i);
  818.             ServizioApplicativo sa = null;
  819.             if(pdSa.getNome()==null){
  820.                 this.errori.add("La porta delegata "+idPortaDelegata+" ha associato un servizio applicativo per cui non e' stato definito il nome");
  821.                 continue;
  822.             }
  823.             else{
  824.                 // servizio applicativo definito nella root del soggetto
  825.                 if(existsServizioApplicativo(pdSa.getNome(), sogg)==false){
  826.                     this.errori.add("La porta delegata "+idPortaDelegata+" ha associato un riferimento ad un servizio applicativo ["+pdSa.getNome()+"] che non risulta registrato nel soggetto "+sogg.getTipo()+"/"+sogg.getNome());
  827.                     continue;
  828.                 }
  829.                 else{
  830.                     // Prelevo servizio applicativo per conformita con l'utilizzo nella porta delegata
  831.                     sa = this.getServizioApplicativo(pdSa.getNome(), sogg);
  832.                     if(sa==null) {
  833.                         this.errori.add("La porta delegata "+idPortaDelegata+" ha associato un riferimento ad un servizio applicativo ["+pdSa.getNome()+"] che non risulta registrato nel soggetto "+sogg.getTipo()+"/"+sogg.getNome());
  834.                         continue;
  835.                     }
  836.                 }
  837.             }
  838.             
  839.             // Validazione conformita' con porta delegata
  840.             if(CostantiConfigurazione.INVOCAZIONE_SERVIZIO_AUTENTICAZIONE_NONE.equals(autenticazione)==false){
  841.                 if(sa.getInvocazionePorta()==null){
  842.                     this.errori.add("La porta delegata "+idPortaDelegata+" possiede un meccanismo di autenticazione ["+autenticazione+"]: il servizio applicativo "+sa.getNome() +" non contiene la definizione dell'elemento invocazione porta");
  843.                 }
  844.                 else if(sa.getInvocazionePorta().sizeCredenzialiList()<=0){
  845.                     this.errori.add("La porta delegata "+idPortaDelegata+" possiede un meccanismo di autenticazione ["+autenticazione+"]: il servizio applicativo "+sa.getNome() +" non contiene la definizione di credenziali di accesso");
  846.                 }
  847.                 else{
  848.                     if(CostantiConfigurazione.CREDENZIALE_BASIC.equals(autenticazione) ||
  849.                             CostantiConfigurazione.CREDENZIALE_APIKEY.equals(autenticazione) ||
  850.                             CostantiConfigurazione.CREDENZIALE_SSL.equals(autenticazione)  ||
  851.                             CostantiConfigurazione.CREDENZIALE_PRINCIPAL.equals(autenticazione)){
  852.                         boolean trovato = false;
  853.                         for(int k=0; k<sa.getInvocazionePorta().sizeCredenzialiList(); k++){
  854.                             if(autenticazione.equals(sa.getInvocazionePorta().getCredenziali(k).getTipo().getValue())){
  855.                                 trovato=true;
  856.                                 break;
  857.                             }
  858.                         }
  859.                         if(!trovato){
  860.                             this.errori.add("La porta delegata "+idPortaDelegata+" possiede un meccanismo di autenticazione ["+autenticazione+"]: il servizio applicativo "+sa.getNome() +" non contiene la definizione di credenziali di accesso compatibili");
  861.                         }
  862.                     }
  863.                 }
  864.             }
  865.         }

  867.         // Valida SetProtocolProperties
  868.         for (int j=0; j<pd.sizeProprietaList();j++) {
  869.             Proprieta ssp = pd.getProprieta(j);
  870.             validaProtocolProperty(ssp, "PortaDelegata_"+idPortaDelegata);
  871.         }
  872.         
  873.         // Valida MessageSecurity
  874.         MessageSecurity messageSecurity = pd.getMessageSecurity();
  875.         if (messageSecurity != null)
  876.             validaMessageSecurity(messageSecurity,"PortaDelegata_"+idPortaDelegata);

  878.         // Valida MTOM
  879.         MtomProcessor mtom = pd.getMtomProcessor();
  880.         if (mtom != null)
  881.             validaMTOM(mtom,"PortaDelegata_"+idPortaDelegata);
  882.         
  883.         // Valida ValidazioneContenutiApplicativi
  884.         ValidazioneContenutiApplicativi vca = pd.getValidazioneContenutiApplicativi();
  885.         if (vca != null)
  886.             validazioneValidazioneContenutiApplicativi(vca, "PortaDelegata_"+idPortaDelegata);
  887.             
  888.         // CorrelazioneApplicativa:
  889.         String idRisorsa = "Porta delegata "+idPortaDelegata;
  890.         validaCorrelazioneApplicativaRichiesta(idRisorsa,pd.getCorrelazioneApplicativa(),true);
  891.         validaCorrelazioneApplicativaRisposta(idRisorsa,pd.getCorrelazioneApplicativaRisposta(),true);

  893.         // XSD: ricevuta-asincrona-simmetrica: abilitato, disabilitato
  894.         StatoFunzionalita ricAsiSim = pd.getRicevutaAsincronaSimmetrica();
  895.         if ((ricAsiSim != null) && !ricAsiSim.equals(CostantiConfigurazione.ABILITATO) && !ricAsiSim.equals(CostantiConfigurazione.DISABILITATO))
  896.             this.errori.add("La ricevuta asincrona simmetrica della porta delegata "+idPortaDelegata+" deve assumere i valori: "+
  897.                     CostantiConfigurazione.ABILITATO+" o "+CostantiConfigurazione.DISABILITATO);

  899.         // XSD: ricevuta-asincrona-asimmetrica: abilitato, disabilitato
  900.         StatoFunzionalita ricAsiAsim = pd.getRicevutaAsincronaAsimmetrica();
  901.         if ((ricAsiAsim != null) && !ricAsiAsim.equals(CostantiConfigurazione.ABILITATO) && !ricAsiAsim.equals(CostantiConfigurazione.DISABILITATO))
  902.             this.errori.add("La ricevuta asincrona asimmetrica della porta delegata "+idPortaDelegata+" deve assumere i valori: "+
  903.                     CostantiConfigurazione.ABILITATO+" o "+CostantiConfigurazione.DISABILITATO);

  905.         // Integrazione
  906.         String integrazione = pd.getIntegrazione();
  907.         if(integrazione!=null){
  908.             String [] tipiIntegrazione = integrazione.split(",");
  909.             if(tipiIntegrazione==null || tipiIntegrazione.length<=0){
  910.                 this.errori.add("La porta delegata "+idPortaDelegata+" possiede un valore nel campo 'integrazione' non valido: "+integrazione);
  911.             }
  912.             else {
  913.                 for(int p=0;p<tipiIntegrazione.length;p++){
  914.                     String tipoI = tipiIntegrazione[p].trim();
  915.                     if(this.tipoIntegrazionePD.contains(tipoI)==false){
  916.                         this.errori.add("La porta delegata "+idPortaDelegata+" possiede un tipo di integrazione ["+tipoI+"] non valido: valori utilizzabili sono: "+this.getTipoIntegrazionePD());
  917.                     }
  918.                 }
  919.             }
  920.         }
  921.         
  922.         // XSD: allega-body: abilitato, disabilitato
  923.         StatoFunzionalita allegaBody = pd.getAllegaBody();
  924.         if ((allegaBody != null) && !allegaBody.equals(CostantiConfigurazione.ABILITATO) && !allegaBody.equals(CostantiConfigurazione.DISABILITATO))
  925.             this.errori.add("La funzionalita' di allega-boxy della porta delegata "+idPortaDelegata+" deve assumere i valori: "+
  926.                     CostantiConfigurazione.ABILITATO+" o "+CostantiConfigurazione.DISABILITATO);

  928.         // XSD: scarta-body: abilitato, disabilitato
  929.         StatoFunzionalita scartaBody = pd.getScartaBody();
  930.         if ((scartaBody != null) && !scartaBody.equals(CostantiConfigurazione.ABILITATO) && !scartaBody.equals(CostantiConfigurazione.DISABILITATO))
  931.             this.errori.add("La funzionalita' di scarta-boxy della porta delegata "+idPortaDelegata+" deve assumere i valori: "+
  932.                     CostantiConfigurazione.ABILITATO+" o "+CostantiConfigurazione.DISABILITATO);

  934.         // XSD: gestione-manifest: abilitato, disabilitato
  935.         StatoFunzionalita gestMan = pd.getGestioneManifest();
  936.         if ((gestMan != null) && !gestMan.equals(CostantiConfigurazione.ABILITATO) && !gestMan.equals(CostantiConfigurazione.DISABILITATO))
  937.             this.errori.add("La funzionalita' di gestioneManifest della porta delegata "+idPortaDelegata+" deve assumere i valori: "+
  938.                     CostantiConfigurazione.ABILITATO+" o "+CostantiConfigurazione.DISABILITATO);
  939.         
  940.         // XSD: stateless: abilitato, disabilitato
  941.         StatoFunzionalita stateless = pd.getStateless();
  942.         if ((stateless != null) && !stateless.equals(CostantiConfigurazione.ABILITATO) && !stateless.equals(CostantiConfigurazione.DISABILITATO))
  943.             this.errori.add("La funzionalita' 'stateless' della porta delegata "+idPortaDelegata+" deve assumere i valori: "+
  944.                     CostantiConfigurazione.ABILITATO+" o "+CostantiConfigurazione.DISABILITATO);
  945.         
  946.         // XSD: local-forward: abilitato, disabilitato
  947.         StatoFunzionalita localForward = null;
  948.         if(pd.getLocalForward()!=null){
  949.             localForward = pd.getLocalForward().getStato();
  950.         }
  951.         if ((localForward != null) && !localForward.equals(CostantiConfigurazione.ABILITATO) && !localForward.equals(CostantiConfigurazione.DISABILITATO))
  952.             this.errori.add("La funzionalita' 'local-forward' della porta delegata "+idPortaDelegata+" deve assumere i valori: "+
  953.                     CostantiConfigurazione.ABILITATO+" o "+CostantiConfigurazione.DISABILITATO);
  954.         
  955.         // ruoli
  956.         if(pd.getRuoli()!=null){
  957.             for (int i = 0; i < pd.getRuoli().sizeRuoloList(); i++) {
  958.                 String nomeRuolo = pd.getRuoli().getRuolo(i).getNome();
  959.                 try{
  960.                     if (!RegularExpressionEngine.isMatch(nomeRuolo,"^[0-9A-Za-z_]+$")) {
  961.                         this.errori.add("Il ruolo ["+nomeRuolo+"] della porta delegata "+idPortaDelegata+" dev'essere formato solo da caratteri, cifre e '_'");
  962.                     }
  963.                 }catch(Exception e){
  964.                     throw new DriverConfigurazioneException("Errore durante l'analisi tramite espressione regolare del nome del ruolo "+nomeRuolo+" della porta delegata "+idPortaDelegata+" :" +e.getMessage(),e);
  965.                 }
  966.             }
  967.             // Ogni ruolo deve avere un nome diverso!
  968.             for (int i = 0; i < pd.getRuoli().sizeRuoloList(); i++) {
  969.                 int numRuolo = 0;
  970.                 String tmpRuolo = pd.getRuoli().getRuolo(i).getNome();
  971.                 for (int j = 0; j < pd.getRuoli().sizeRuoloList(); j++) {
  972.                     String checkRuolo = pd.getRuoli().getRuolo(j).getNome();
  973.                     if (checkRuolo.equals(tmpRuolo))
  974.                         numRuolo++; 
  975.                 }
  976.                 if (numRuolo > 1)
  977.                     this.errori.add("Non può esistere più di un ruolo con nome "+tmpRuolo+". Trovate "+numRuolo+" occorrenze nella porta delegata "+idPortaDelegata);
  978.             }
  979.         }
  980.     }

  982.     private  void validaPortaApplicativa(PortaApplicativa pa, Soggetto sogg) throws DriverConfigurazioneException {
  983.         
  984.         if(pa.getNome()==null){
  985.             this.errori.add("Il soggetto ["+sogg.getTipo()+"/"+sogg.getNome()+"] posside una porta applicativa che non contiene la definizione del nome");
  986.             return;
  987.         }
  988.         
  989.         String nomePorta = pa.getNome();
  990.         String idPortaApplicativa = "("+sogg.getTipo()+"/"+sogg.getNome()+") "+nomePorta;
  991.         
  992.         // La porta applicativa viene identificata dal nome.
  993.         // Una volta identificata la sua stringa di identificazione DEVE essere univoca tra tutte le porte applicative di TUTTA la configurazione 
  994.         // (e non solo tra quelle del soggetto proprietario)
  995.         int numPD = 0;
  996.         List<String> paTrovate = new ArrayList<>();
  997.         for(int j=0; j<this.configurazione.sizeSoggettoList();j++){
  998.             Soggetto s = this.configurazione.getSoggetto(j);
  999.             for(int k =0; k<s.sizePortaApplicativaList(); k++){
  1000.                 PortaApplicativa tmpPa = s.getPortaApplicativa(k);
  1001.                 String tmpNomePorta = tmpPa.getNome();
  1002.                 if (nomePorta.equals(tmpNomePorta)){
  1003.                     numPD++;
  1004.                     paTrovate.add("("+s.getTipo()+"/"+s.getNome()+") "+tmpPa.getNome());
  1005.                 }
  1006.             }
  1007.         }
  1008.         if (numPD > 1)
  1009.             this.errori.add("Non può esistere più di una porta applicativa con nome "+nomePorta+". Sono state identificate le seguenti porte applicative: "+paTrovate);

  1011.         
  1012.         
  1013.         
  1014.         // Il vincolo è stato eliminato nella versione 3.0
  1015.         @SuppressWarnings("unused")
  1016.         boolean checkIDPA = true; // Info per sapere se abbiamo abbastanza informazioni per costruire l'id
  1017.         
  1018.         // SoggettoVirtuale
  1019.         if(pa.getSoggettoVirtuale()!=null){
  1020.             
  1021.             PortaApplicativaSoggettoVirtuale sv = pa.getSoggettoVirtuale();
  1022.             
  1023.             if(sv.getTipo()==null){
  1024.                 this.errori.add("La porta applicativa ["+idPortaApplicativa+"] possiede la definizione di un soggetto virtuale per cui non e' stato definito il tipo");
  1025.                 checkIDPA = false;
  1026.             }
  1027.             else if(this.tipoSoggetti.contains(sv.getTipo())==false){
  1028.                 this.errori.add("La porta applicativa ["+idPortaApplicativa+"] possiede la definizione di un soggetto virtuale per cui e' stato definito un tipo non valido (Tipi utilizzabili: "+this.getTipoSoggetti()+")");
  1029.             }
  1030.             
  1031.             if(sv.getNome()==null){
  1032.                 this.errori.add("La porta applicativa ["+idPortaApplicativa+"] possiede la definizione di un soggetto virtuale per cui non e' stato definito il nome");
  1033.                 checkIDPA = false;
  1034.             }
  1035.             
  1036.         }
  1037.         
  1038.         // Servizio
  1039.         if(pa.getServizio()!=null){
  1040.             
  1041.             PortaApplicativaServizio serv = pa.getServizio();
  1042.             
  1043.             if(serv.getTipo()==null){
  1044.                 this.errori.add("La porta applicativa ["+idPortaApplicativa+"] possiede la definizione di un servizio erogato per cui non e' stato definito il tipo");
  1045.                 checkIDPA = false;
  1046.             }
  1047.             else if(this.tipoServiziSoap.contains(serv.getTipo())==false && this.tipoServiziRest.contains(serv.getTipo())==false){
  1048.                 this.errori.add("La porta applicativa ["+idPortaApplicativa+"] possiede la definizione di un servizio erogato per cui e' stato definito un tipo non valido (Tipi utilizzabili: "+this.getTipoServizi()+")");
  1049.             }
  1050.             
  1051.             if(serv.getNome()==null){
  1052.                 this.errori.add("La porta applicativa ["+idPortaApplicativa+"] possiede la definizione di un servizio erogato per cui non e' stato definito il nome");
  1053.                 checkIDPA = false;
  1054.             }
  1055.             
  1056.         }else{
  1057.             
  1058.             this.errori.add("La porta applicativa ["+idPortaApplicativa+"] non possiede la definizione del servizio erogato");
  1059.             
  1060.         }
  1061.         
  1062.         // Azione
  1063.         if(pa.getAzione()!=null){
  1064.             
  1065.             PortaApplicativaAzione pda = pa.getAzione();
  1066.             
  1067.             // XSD: identificazione: static, urlBased, contentBased, inputBased e soapActionBased
  1068.             PortaApplicativaAzioneIdentificazione identificazione = pda.getIdentificazione();
  1069.             if ((identificazione != null) && !identificazione.equals(CostantiConfigurazione.PORTA_APPLICATIVA_AZIONE_STATIC) && 
  1070.                     !identificazione.equals(CostantiConfigurazione.PORTA_APPLICATIVA_AZIONE_URL_BASED) && 
  1071.                     !identificazione.equals(CostantiConfigurazione.PORTA_APPLICATIVA_AZIONE_CONTENT_BASED) &&
  1072.                     !identificazione.equals(CostantiConfigurazione.PORTA_APPLICATIVA_AZIONE_HEADER_BASED) && 
  1073.                     !identificazione.equals(CostantiConfigurazione.PORTA_APPLICATIVA_AZIONE_PROTOCOL_BASED) && 
  1074.                     !identificazione.equals(CostantiConfigurazione.PORTA_APPLICATIVA_AZIONE_INPUT_BASED) && 
  1075.                     !identificazione.equals(CostantiConfigurazione.PORTA_APPLICATIVA_AZIONE_SOAP_ACTION_BASED) &&
  1076.                     !identificazione.equals(CostantiConfigurazione.PORTA_APPLICATIVA_AZIONE_WSDL_BASED) &&
  1077.                     !identificazione.equals(CostantiConfigurazione.PORTA_APPLICATIVA_AZIONE_DELEGATED_BY)){
  1078.                 this.errori.add("La modalita d'identificazione dell'azione della porta applicativa "+idPortaApplicativa+" deve assumere uno dei seguente valori: "+
  1079.                         CostantiConfigurazione.PORTA_APPLICATIVA_AZIONE_STATIC+", "+
  1080.                         CostantiConfigurazione.PORTA_APPLICATIVA_AZIONE_URL_BASED+", "+
  1081.                         CostantiConfigurazione.PORTA_APPLICATIVA_AZIONE_CONTENT_BASED+", "+
  1082.                         CostantiConfigurazione.PORTA_APPLICATIVA_AZIONE_HEADER_BASED+" o "+
  1083.                         CostantiConfigurazione.PORTA_APPLICATIVA_AZIONE_PROTOCOL_BASED+" o "+
  1084.                         CostantiConfigurazione.PORTA_APPLICATIVA_AZIONE_INPUT_BASED+" o "+
  1085.                         CostantiConfigurazione.PORTA_APPLICATIVA_AZIONE_SOAP_ACTION_BASED+" o "+
  1086.                         CostantiConfigurazione.PORTA_APPLICATIVA_AZIONE_WSDL_BASED+" o "+
  1087.                         CostantiConfigurazione.PORTA_APPLICATIVA_AZIONE_DELEGATED_BY);
  1088.             }
  1089.             if(identificazione==null){
  1090.                 identificazione = CostantiConfigurazione.PORTA_APPLICATIVA_AZIONE_STATIC;
  1091.             }
  1092.             
  1093.             if(CostantiConfigurazione.PORTA_APPLICATIVA_AZIONE_STATIC.equals(identificazione)){
  1094.                 if (pda.getNome() == null){
  1095.                     this.errori.add("L'azione della porta applicativa "+idPortaApplicativa+" non contiene la definizione del nome, nonostante la modalita' di identificazione sia "+identificazione);
  1096.                     checkIDPA = false;
  1097.                 }
  1098.             }
  1099.             else if(CostantiConfigurazione.PORTA_APPLICATIVA_AZIONE_URL_BASED.equals(identificazione) || 
  1100.                     CostantiConfigurazione.PORTA_APPLICATIVA_AZIONE_CONTENT_BASED.equals(identificazione) || 
  1101.                     CostantiConfigurazione.PORTA_APPLICATIVA_AZIONE_HEADER_BASED.equals(identificazione)){
  1102.                 if (pda.getPattern() == null){
  1103.                     this.errori.add("L'azione della porta applicativa "+idPortaApplicativa+" non contiene la definizione del pattern, nonostante la modalita' di identificazione sia "+identificazione);
  1104.                     checkIDPA = false;
  1105.                 }
  1106.             }   
  1107.             else if(CostantiConfigurazione.PORTA_APPLICATIVA_AZIONE_DELEGATED_BY.equals(identificazione)){
  1108.                 if (pda.getNomePortaDelegante() == null) {
  1109.                     this.errori.add("L'azione della porta delegata "+idPortaApplicativa+" non contiene la definizione del nome della porta delegante, nonostante la modalita' di identificazione sia "+identificazione);
  1110.                     checkIDPA = false;
  1111.                 }
  1112.             }
  1113.             
  1114.         }
  1115.         
  1116.         // Servizi Applicativi
  1117.         if(pa.sizeServizioApplicativoList()<1){
  1118.             this.errori.add("Alla porta applicativa ["+idPortaApplicativa+"] non sono stati associati servizi applicativi");
  1119.         }
  1120.         else{
  1121.             for(int i=0; i<pa.sizeServizioApplicativoList(); i++){
  1122.                 // Servizio Applicativo puo' avere solo meta informazioni
  1123.                 PortaApplicativaServizioApplicativo paSa = pa.getServizioApplicativo(i);
  1124.                 ServizioApplicativo sa = null;
  1125.                 if(paSa.getNome()==null){
  1126.                     this.errori.add("La porta applicativa "+idPortaApplicativa+" ha associato un servizio applicativo per cui non e' stato definito il nome");
  1127.                     continue;
  1128.                 }
  1129.                 else{
  1130.                     // servizio applicativo definito nella root del soggetto
  1131.                     if(existsServizioApplicativo(paSa.getNome(), sogg)==false){
  1132.                         this.errori.add("La porta applicativa "+idPortaApplicativa+" ha associato un riferimento ad un servizio applicativo ["+paSa.getNome()+"] che non risulta registrato nel soggetto "+sogg.getTipo()+"/"+sogg.getNome());
  1133.                         continue;
  1134.                     }
  1135.                     else{
  1136.                         // Prelevo servizio applicativo per conformita con l'utilizzo nella porta applicativa
  1137.                         sa = this.getServizioApplicativo(paSa.getNome(), sogg);
  1138.                     }
  1139.                 }
  1140.                 
  1141.                 // Validazione conformita' con porta applicativa
  1142.                 if(sa.getInvocazioneServizio()==null){
  1143.                     this.errori.add("La porta applicativa "+idPortaApplicativa+" ha associato un servizio applicativo ["+sa.getNome()+"] per cui non e' stato definito l'elemento invocazione servizio");
  1144.                 }
  1145.                 else{
  1146.                     boolean connettore = false;
  1147.                     boolean get = false;
  1148.                     if(sa.getInvocazioneServizio().getConnettore()!=null && !CostantiConfigurazione.DISABILITATO.equals(sa.getInvocazioneServizio().getConnettore().getTipo())){
  1149.                         connettore = true;
  1150.                     }
  1151.                     if(sa.getInvocazioneServizio().getGetMessage()!=null && CostantiConfigurazione.ABILITATO.equals(sa.getInvocazioneServizio().getGetMessage())){
  1152.                         get = true;
  1153.                     }
  1154.                     if(!connettore && !get){
  1155.                         this.errori.add("La porta applicativa "+idPortaApplicativa+" ha associato un servizio applicativo ["+sa.getNome()+"] per cui non e' stato definito ne una consegna trasparente (tramite connettore) ne il servizio di message box (tramite IntegrationManager)");
  1156.                     }
  1157.                 }
  1158.             }
  1159.         }

  1161.         // Check processo di autenticazione della porta delegata
  1162.         String autenticazione = CredenzialeTipo.SSL.toString();
  1163.         if(pa.getAutenticazione()!=null){
  1164.             autenticazione = pa.getAutenticazione();
  1165.             if(this.tipoAutenticazionePortaApplicativa.contains(pa.getAutenticazione())==false){
  1166.                 this.errori.add("Alla porta applicativa "+idPortaApplicativa+" e' stato associato un processo di autenticazione ["+pa.getAutenticazione()+"] non valido; tipi conosciuti: "+this.getTipoAutenticazionePortaApplicativa()); 
  1167.             }
  1168.         }
  1169.         
  1170.         // Autorizzazione
  1171.         String autorizzazione = CostantiConfigurazione.AUTORIZZAZIONE_AUTHENTICATED;
  1172.         if(pa.getAutorizzazione()!=null){
  1173.             autorizzazione = pa.getAutorizzazione();
  1174.             if(this.tipoAutorizzazionePortaApplicativa.contains(pa.getAutorizzazione())==false){
  1175.                 this.errori.add("Alla porta applicativa "+idPortaApplicativa+" e' stato associato un processo di autorizzazione ["+pa.getAutorizzazione()+"] non valido; tipi conosciuti: "+this.getTipoAutorizzazionePortaApplicativa()); 
  1176.             }
  1177.         }
  1178.         
  1179.         if(autorizzazione!=null){
  1180.         
  1181.             // Questi vincoli non valgono in spcoop e nello sdi
  1182.             if("gw".equals(sogg.getTipo())){
  1183.                 if(autorizzazione.toLowerCase().contains(CostantiConfigurazione.AUTORIZZAZIONE_AUTHENTICATED) &&
  1184.                         autorizzazione.toLowerCase().contains(CostantiConfigurazione.AUTORIZZAZIONE_ROLES)){
  1185.                     // Se e' definito un processo di autorizzazione che prevede sia autenticazione che ruoli l'autenticazione deve essere opzionale
  1186.                     if(StatoFunzionalita.ABILITATO.equals(pa.getAutenticazioneOpzionale())==false){
  1187.                         this.errori.add("Alla porta applicativa "+idPortaApplicativa+" e' stato associata un'autorizzazione '"+autorizzazione+"' che richiede una autenticazione dei soggetti opzionali"); 
  1188.                     }
  1189.                 }
  1190.                 if(autorizzazione.toLowerCase().contains("internal") || 
  1191.                         (CostantiConfigurazione.AUTORIZZAZIONE_AUTHENTICATED.equals(autorizzazione))){
  1192.                     // Se l'autorizzazione prevede una gestione dei ruoli interni, oppure è solamente basata sull'autenticazione dei chiamanti, 
  1193.                     // una autenticazione DEVE essere presente e non deve essere opzionale
  1194.                     if(CostantiConfigurazione.AUTENTICAZIONE_NONE.equals(autenticazione)){
  1195.                         this.errori.add("Alla porta applicativa "+idPortaApplicativa+" e' stato associata un'autorizzazione '"+autorizzazione+"' che richiede una autenticazione obbligatoria dei soggetti, autenticazione non impostata nella porta applicativa"); 
  1196.                     }
  1197.                     if(StatoFunzionalita.ABILITATO.equals(pa.getAutenticazioneOpzionale())){
  1198.                         if(autorizzazione.toLowerCase().contains("or")==false){
  1199.                             this.errori.add("Alla porta applicativa "+idPortaApplicativa+" e' stato associata un'autorizzazione '"+autorizzazione+"' che richiede una autenticazione obbligatoria dei soggetti, autenticazione impostata come opzionale nella porta applicativa");
  1200.                         }
  1201.                     }
  1202.                 }
  1203.             }
  1204.             
  1205.         }

  1207.         // Vincoli troppo forti nel caso di configurazione su console, la PdD non parte se la configurazione non e' stata ultimata.
  1208. //      if(autorizzazione!=null && autorizzazione.toLowerCase().contains(CostantiConfigurazione.AUTORIZZAZIONE_ROLES.toLowerCase())){
  1209. //          if (pa.getRuoli()==null || pa.getRuoli().sizeRuoloList() == 0){
  1210. //              this.errori.add("La porta applicativa "+idPortaApplicativa+" deve avere almeno un ruolo associato poiche' lo richiede il tipo di autorizzazione indicato: "+autorizzazione);
  1211. //          }
  1212. //      }
  1213.         
  1214.         // Autorizzazione Contenuto
  1215.         if(pa.getAutorizzazioneContenuto()!=null){
  1216.             if(this.tipoAutorizzazioneContenutoPortaApplicativa.contains(pa.getAutorizzazioneContenuto())==false){
  1217.                 this.errori.add("Alla porta applicativa "+idPortaApplicativa+" e' stato associato un processo di autorizzazione contenuto ["+pa.getAutorizzazioneContenuto()+"] non valido; tipi conosciuti: "+this.getTipoAutorizzazioneContenutoPortaApplicativa()); 
  1218.             }
  1219.         }
  1220.         
  1221.         // Valida SetProtocolProperties
  1222.         for (int j=0; j<pa.sizeProprietaList();j++) {
  1223.             Proprieta ssp = pa.getProprieta(j);
  1224.             validaProtocolProperty(ssp, "PortaApplicativa_"+idPortaApplicativa);
  1225.         }

  1227.         // Valida MessageSecurity
  1228.         MessageSecurity messageSecurity = pa.getMessageSecurity();
  1229.         if (messageSecurity != null)
  1230.             validaMessageSecurity(messageSecurity,"PortaApplicativa_"+idPortaApplicativa);

  1232.         // Valida MTOM
  1233.         MtomProcessor mtom = pa.getMtomProcessor();
  1234.         if (mtom != null)
  1235.             validaMTOM(mtom,"PortaApplicativa_"+idPortaApplicativa);

  1237.         // Valida ValidazioneContenutiApplicativi
  1238.         ValidazioneContenutiApplicativi vca = pa.getValidazioneContenutiApplicativi();
  1239.         if (vca != null)
  1240.             validazioneValidazioneContenutiApplicativi(vca, "PortaApplicativa_"+idPortaApplicativa);

  1242.         // CorrelazioneApplicativa:
  1243.         String idRisorsa = "Porta applicativa "+idPortaApplicativa;
  1244.         validaCorrelazioneApplicativaRichiesta(idRisorsa,pa.getCorrelazioneApplicativa(),false);
  1245.         validaCorrelazioneApplicativaRisposta(idRisorsa,pa.getCorrelazioneApplicativaRisposta(),false);
  1246.                 
  1247.         // Il nome della porta applicativa (obbligatorio) deve essere univoco tra i nomi delle porte applicative del soggetto.
  1248.         int numPA = 0;
  1249.         for (int j=0; j<sogg.sizePortaApplicativaList(); j++) {
  1250.             PortaApplicativa tmpPa = sogg.getPortaApplicativa(j);
  1251.             if (pa.getNome().equals(tmpPa.getNome()))
  1252.                 numPA++;
  1253.         }
  1254.         if (numPA > 1)
  1255.             this.errori.add("Non può esistere più di una porta applicativa del soggetto "+sogg.getTipo()+"/"+sogg.getNome()+" con nome "+pa.getNome());
  1256.     
  1257.         //Check univocita' anche per valori soggetto (virtuale), servizio e azione
  1258.         // Il vincolo è stato eliminato nella versione 3.0
  1259. //      String idPortaA = null;
  1260. //      if(checkIDPA == false){
  1261. //          
  1262. //          if(pa.getSoggettoVirtuale()!=null){
  1263. //              idPortaA = pa.getSoggettoVirtuale().getTipo()+"/"+pa.getSoggettoVirtuale().getNome();
  1264. //          }
  1265. //          else{
  1266. //              idPortaA = sogg.getTipo()+"/"+sogg.getNome();
  1267. //          }
  1268. //          idPortaA = idPortaA +"_" + pa.getServizio().getTipo()+"/"+pa.getServizio().getNome(); 
  1269. //          if(pa.getAzione()!=null){
  1270. //              idPortaA = idPortaA +"_" +pa.getAzione().getNome();
  1271. //          }
  1272. //          
  1273. //          int cont = 0;
  1274. //          for(int i=0; i<sogg.sizePortaApplicativaList(); i++){
  1275. //              PortaApplicativa tmp = sogg.getPortaApplicativa(i);
  1276. //              String idTMPPA = null;
  1277. //              if(tmp.getSoggettoVirtuale()!=null){
  1278. //                  if(tmp.getSoggettoVirtuale().getTipo()==null)
  1279. //                      continue; // PA malformata, verra segnalata
  1280. //                  if(tmp.getSoggettoVirtuale().getNome()==null)
  1281. //                      continue; // PA malformata, verra segnalata
  1282. //                  idTMPPA = tmp.getSoggettoVirtuale().getTipo()+"/"+tmp.getSoggettoVirtuale().getNome();
  1283. //              }
  1284. //              else{
  1285. //                  idTMPPA = sogg.getTipo()+"/"+sogg.getNome();
  1286. //              }
  1287. //              if(tmp.getServizio()==null)
  1288. //                  continue; // PA malformata, verra segnalata
  1289. //              if(tmp.getServizio().getTipo()==null)
  1290. //                  continue; // PA malformata, verra segnalata
  1291. //              if(tmp.getServizio().getNome()==null)
  1292. //                  continue; // PA malformata, verra segnalata
  1293. //              idTMPPA = idTMPPA +"_" + tmp.getServizio().getTipo()+"/"+tmp.getServizio().getNome(); 
  1294. //              if(tmp.getAzione()!=null){
  1295. //                  if(tmp.getAzione().getNome()==null){
  1296. //                      continue; // PA malformata, verra segnalata
  1297. //                  }
  1298. //                  idTMPPA = idTMPPA +"_" +pa.getAzione().getNome();
  1299. //              }
  1300. //              if(idPortaA.equals(idTMPPA)){
  1301. //                  cont++;
  1302. //              }
  1303. //          }
  1304. //          
  1305. //          if(cont>1){
  1306. //              if(pa.getSoggettoVirtuale()!=null)
  1307. //                  this.errori.add("Non può esistere più di una porta applicativa (con soggetto virtuale) che mappa il servizio: "+idPortaA);
  1308. //              else
  1309. //                  this.errori.add("Non può esistere più di una porta applicativa che mappa il servizio: "+idPortaA);
  1310. //          }
  1311. //      }
  1312.         
  1313.         
  1314.         // XSD: ricevuta-asincrona-simmetrica: abilitato, disabilitato
  1315.         StatoFunzionalita ricAsiSim = pa.getRicevutaAsincronaSimmetrica();
  1316.         if ((ricAsiSim != null) && !ricAsiSim.equals(CostantiConfigurazione.ABILITATO) && !ricAsiSim.equals(CostantiConfigurazione.DISABILITATO))
  1317.             this.errori.add("La ricevuta asincrona simmetrica della porta applicativa "+idPortaApplicativa+" deve assumere i valori: "+
  1318.                     CostantiConfigurazione.ABILITATO+" o "+CostantiConfigurazione.DISABILITATO);

  1320.         // XSD: ricevuta-asincrona-asimmetrica: abilitato, disabilitato
  1321.         StatoFunzionalita ricAsiAsim = pa.getRicevutaAsincronaAsimmetrica();
  1322.         if ((ricAsiAsim != null) && !ricAsiAsim.equals(CostantiConfigurazione.ABILITATO) && !ricAsiAsim.equals(CostantiConfigurazione.DISABILITATO))
  1323.             this.errori.add("La ricevuta asincrona asimmetrica della porta applicativa "+idPortaApplicativa+" deve assumere i valori: "+
  1324.                     CostantiConfigurazione.ABILITATO+" o "+CostantiConfigurazione.DISABILITATO);

  1326.         // Integrazione
  1327.         String integrazione = pa.getIntegrazione();
  1328.         if(integrazione!=null){
  1329.             String [] tipiIntegrazione = integrazione.split(",");
  1330.             if(tipiIntegrazione==null || tipiIntegrazione.length<=0){
  1331.                 this.errori.add("La porta applicativa "+idPortaApplicativa+" possiede un valore nel campo 'integrazione' non valido: "+integrazione);
  1332.             }
  1333.             else {
  1334.                 for(int p=0;p<tipiIntegrazione.length;p++){
  1335.                     String tipoI = tipiIntegrazione[p].trim();
  1336.                     if(this.tipoIntegrazionePA.contains(tipoI)==false){
  1337.                         this.errori.add("La porta applicativa "+idPortaApplicativa+" possiede un tipo di integrazione ["+tipoI+"] non valido: valori utilizzabili sono: "+this.getTipoIntegrazionePA());
  1338.                     }
  1339.                 }
  1340.             }
  1341.         }
  1342.         
  1343.         // XSD: allega-body: abilitato, disabilitato
  1344.         StatoFunzionalita allegaBody = pa.getAllegaBody();
  1345.         if ((allegaBody != null) && !allegaBody.equals(CostantiConfigurazione.ABILITATO) && !allegaBody.equals(CostantiConfigurazione.DISABILITATO))
  1346.             this.errori.add("La funzionalita' di allega-boxy della porta applicativa "+idPortaApplicativa+" deve assumere i valori: "+
  1347.                     CostantiConfigurazione.ABILITATO+" o "+CostantiConfigurazione.DISABILITATO);

  1349.         // XSD: scarta-body: abilitato, disabilitato
  1350.         StatoFunzionalita scartaBody = pa.getScartaBody();
  1351.         if ((scartaBody != null) && !scartaBody.equals(CostantiConfigurazione.ABILITATO) && !scartaBody.equals(CostantiConfigurazione.DISABILITATO))
  1352.             this.errori.add("La funzionalita' di scarta-boxy della porta applicativa "+idPortaApplicativa+" deve assumere i valori: "+
  1353.                     CostantiConfigurazione.ABILITATO+" o "+CostantiConfigurazione.DISABILITATO);

  1355.         // XSD: gestione-manifest: abilitato, disabilitato
  1356.         StatoFunzionalita gestMan = pa.getGestioneManifest();
  1357.         if ((gestMan != null) && !gestMan.equals(CostantiConfigurazione.ABILITATO) && !gestMan.equals(CostantiConfigurazione.DISABILITATO))
  1358.             this.errori.add("La funzionalita' di gestioneManifest della porta applicativa "+idPortaApplicativa+" deve assumere i valori: "+
  1359.                     CostantiConfigurazione.ABILITATO+" o "+CostantiConfigurazione.DISABILITATO);
  1360.         
  1361.         // XSD: stateless: abilitato, disabilitato
  1362.         StatoFunzionalita stateless = pa.getStateless();
  1363.         if ((stateless != null) && !stateless.equals(CostantiConfigurazione.ABILITATO) && !stateless.equals(CostantiConfigurazione.DISABILITATO))
  1364.             this.errori.add("La funzionalita' 'stateless' della porta applicativa "+idPortaApplicativa+" deve assumere i valori: "+
  1365.                     CostantiConfigurazione.ABILITATO+" o "+CostantiConfigurazione.DISABILITATO);
  1366.         
  1367.         // ruoli
  1368.         if(pa.getRuoli()!=null){
  1369.             for (int i = 0; i < pa.getRuoli().sizeRuoloList(); i++) {
  1370.                 String nomeRuolo = pa.getRuoli().getRuolo(i).getNome();
  1371.                 try{
  1372.                     if (!RegularExpressionEngine.isMatch(nomeRuolo,"^[0-9A-Za-z_]+$")) {
  1373.                         this.errori.add("Il ruolo ["+nomeRuolo+"] della porta applicativa "+idPortaApplicativa+" dev'essere formato solo da caratteri, cifre e '_'");
  1374.                     }
  1375.                 }catch(Exception e){
  1376.                     throw new DriverConfigurazioneException("Errore durante l'analisi tramite espressione regolare del nome del ruolo "+nomeRuolo+" della porta applicativa "+idPortaApplicativa+" :" +e.getMessage(),e);
  1377.                 }
  1378.             }
  1379.             // Ogni ruolo deve avere un nome diverso!
  1380.             for (int i = 0; i < pa.getRuoli().sizeRuoloList(); i++) {
  1381.                 int numRuolo = 0;
  1382.                 String tmpRuolo = pa.getRuoli().getRuolo(i).getNome();
  1383.                 for (int j = 0; j < pa.getRuoli().sizeRuoloList(); j++) {
  1384.                     String checkRuolo = pa.getRuoli().getRuolo(j).getNome();
  1385.                     if (checkRuolo.equals(tmpRuolo))
  1386.                         numRuolo++; 
  1387.                 }
  1388.                 if (numRuolo > 1)
  1389.                     this.errori.add("Non può esistere più di un ruolo con nome "+tmpRuolo+". Trovate "+numRuolo+" occorrenze nella porta applicativa "+idPortaApplicativa);
  1390.             }
  1391.         }
  1392.     }

  1394.     private void validaServizioApplicativo(ServizioApplicativo sa, Soggetto sogg) throws DriverConfigurazioneException {
  1395.         // NOTA: Se checkForAutorizzazione = true, il servizio DEVE possedere l'elemento invocazione porta con ALMENO una credenziale

  1397.         if(sa.getNome()==null){
  1398.             this.errori.add("Esiste un ServizioApplicativo del soggetto ["+sogg.getTipo()+"/"+sogg.getNome()+"] per cui non e' stato definito il nome");
  1399.             return;
  1400.         }
  1401.         
  1402.         String idServizioApplicativo = sogg.getTipo()+"/"+sogg.getNome()+"_"+sa.getNome();
  1403.         
  1404.         if(sa.getInvocazionePorta()==null && sa.getRispostaAsincrona()==null  && sa.getInvocazioneServizio()==null){
  1405.             this.errori.add("Il ServizioApplicativo ["+idServizioApplicativo+"] non contiene ne la definizione dell'elemento invocazione porta, ne la definizione della risposta asincrona, ne la definizione dell'elemento invocazione servizio");
  1406.             return;
  1407.         }
  1408.         
  1409.         // InvocazionePorta
  1410.         InvocazionePorta ip = sa.getInvocazionePorta();
  1411.         if (ip != null) {
  1412.             
  1413.             // Valida Credenziali
  1414.             if(ip.sizeCredenzialiList()<1){
  1415.                 this.errori.add("Il ServizioApplicativo ["+idServizioApplicativo+"] non contiene credenziali di accesso, nonostante abbia definito l'elemento invocazione porta");
  1416.             }
  1417.             for (int j=0; j<ip.sizeCredenzialiList(); j++) {
  1418.                 Credenziali c = ip.getCredenziali(j);
  1419.                 this.validaCredenziale(c, "servizio applicativo ["+idServizioApplicativo+"] (invocazione porta)");
  1420.             }
  1421.             
  1422.             // XSD: invio-per-riferimento: abilitato, disabilitato
  1423.             StatoFunzionalita invRif = ip.getInvioPerRiferimento();
  1424.             if ((invRif != null) && !invRif.equals(CostantiConfigurazione.ABILITATO) && !invRif.equals(CostantiConfigurazione.DISABILITATO))
  1425.                 this.errori.add("L'invio per riferimento dell'invocazione porta del servizio applicativo ["+idServizioApplicativo+"] deve assumere i valori: "+
  1426.                         CostantiConfigurazione.ABILITATO+" o "+CostantiConfigurazione.DISABILITATO);
  1427.             
  1428.             // XSD: sbustamento-informazioni-protocollo: abilitato, disabilitato
  1429.             StatoFunzionalita sbustamentoInfoProtocollo = ip.getSbustamentoInformazioniProtocollo();
  1430.             if ((sbustamentoInfoProtocollo != null) && !sbustamentoInfoProtocollo.equals(CostantiConfigurazione.ABILITATO) && !sbustamentoInfoProtocollo.equals(CostantiConfigurazione.DISABILITATO))
  1431.                 this.errori.add("L'indicazione di sbustamento informazioni di protcollo dell'invocazione porta del servizio applicativo ["+idServizioApplicativo+"] deve assumere i valori: "+
  1432.                         CostantiConfigurazione.ABILITATO+" o "+CostantiConfigurazione.DISABILITATO);
  1433.             
  1434.             InvocazionePortaGestioneErrore ipge = ip.getGestioneErrore();
  1435.             if (ipge != null) {
  1436.                 
  1437.                 // XSD: fault: soap, xml
  1438.                 FaultIntegrazioneTipo fault = ipge.getFault();
  1439.                 if ((fault != null) && !fault.equals(FaultIntegrazioneTipo.SOAP) && !fault.equals(FaultIntegrazioneTipo.XML))
  1440.                     this.errori.add("Il fault della gestione errore dell'invocazione porta del servizio applicativo ["+idServizioApplicativo+"] deve assumere i valori: "+
  1441.                             CostantiConfigurazione.ERRORE_APPLICATIVO_SOAP+" o "+CostantiConfigurazione.ERRORE_APPLICATIVO_XML);

  1443.                 // XSD: generic-fault-code: abilitato, disabilitato
  1444.                 StatoFunzionalita genFault = ipge.getGenericFaultCode();
  1445.                 if ((genFault != null) && !genFault.equals(CostantiConfigurazione.ABILITATO) && !genFault.equals(CostantiConfigurazione.DISABILITATO))
  1446.                     this.errori.add("Il generic-fault-code della gestione errore dell'invocazione porta del servizio applicativo ["+idServizioApplicativo+"] deve assumere i valori: "+
  1447.                             CostantiConfigurazione.ABILITATO+" o "+CostantiConfigurazione.DISABILITATO);
  1448.             }

  1450.             // ruoli
  1451.             if(ip.getRuoli()!=null){
  1452.                 for (int i = 0; i < ip.getRuoli().sizeRuoloList(); i++) {
  1453.                     String nomeRuolo = ip.getRuoli().getRuolo(i).getNome();
  1454.                     try{
  1455.                         if (!RegularExpressionEngine.isMatch(nomeRuolo,"^[0-9A-Za-z_]+$")) {
  1456.                             this.errori.add("Il ruolo ["+nomeRuolo+"] dell'invocazione porta del servizio applicativo ["+idServizioApplicativo+"] dev'essere formato solo da caratteri, cifre e '_'");
  1457.                         }
  1458.                     }catch(Exception e){
  1459.                         throw new DriverConfigurazioneException("Errore durante l'analisi tramite espressione regolare del nome del ruolo "+nomeRuolo+" dell'invocazione porta del servizio applicativo ["+idServizioApplicativo+"] :" +e.getMessage(),e);
  1460.                     }
  1461.                 }
  1462.                 // Ogni ruolo deve avere un nome diverso!
  1463.                 for (int i = 0; i < ip.getRuoli().sizeRuoloList(); i++) {
  1464.                     int numRuolo = 0;
  1465.                     String tmpRuolo = ip.getRuoli().getRuolo(i).getNome();
  1466.                     for (int j = 0; j < ip.getRuoli().sizeRuoloList(); j++) {
  1467.                         String checkRuolo = ip.getRuoli().getRuolo(j).getNome();
  1468.                         if (checkRuolo.equals(tmpRuolo))
  1469.                             numRuolo++; 
  1470.                     }
  1471.                     if (numRuolo > 1)
  1472.                         this.errori.add("Non può esistere più di un ruolo con nome "+tmpRuolo+". Trovate "+numRuolo+" occorrenze nell'invocazione porta del servizio applicativo ["+idServizioApplicativo+"]");
  1473.                 }
  1474.             }
  1475.         }

  1477.         // InvocazioneServizio
  1478.         if (sa.getInvocazioneServizio() != null) {
  1479.             InvocazioneServizio is = sa.getInvocazioneServizio();
  1480.             
  1481.             // Valida Credenziali
  1482.             InvocazioneCredenziali c = is.getCredenziali();
  1483.             if (c != null)
  1484.                 this.validaCredenziale(c, "servizio applicativo ["+idServizioApplicativo+"] (invocazione servizio)");
  1485.                 
  1486.             // Autenticazione
  1487.             // XSD: autenticazione: basic, ssl, none
  1488.             InvocazioneServizioTipoAutenticazione auth = is.getAutenticazione();
  1489.             if ((auth != null) && !auth.equals(CostantiConfigurazione.INVOCAZIONE_SERVIZIO_AUTENTICAZIONE_BASIC) && 
  1490.                     !auth.equals(CostantiConfigurazione.INVOCAZIONE_SERVIZIO_AUTENTICAZIONE_NONE))
  1491.                 this.errori.add("L'autenticazione dell'invocazione servizio del servizio applicativo "+idServizioApplicativo+" deve assumere uno dei seguenti valori: "+
  1492.                         CostantiConfigurazione.INVOCAZIONE_SERVIZIO_AUTENTICAZIONE_BASIC.toString()+" o "+CostantiConfigurazione.INVOCAZIONE_SERVIZIO_AUTENTICAZIONE_NONE.toString());
  1493.             if(CostantiConfigurazione.INVOCAZIONE_SERVIZIO_AUTENTICAZIONE_BASIC.equals(auth)){
  1494.                 if(c==null){
  1495.                     this.errori.add("L'autenticazione "+CostantiConfigurazione.INVOCAZIONE_SERVIZIO_AUTENTICAZIONE_BASIC.toString()+" dell'invocazione servizio del servizio applicativo "+idServizioApplicativo+" richiede la presenza di credenziali");
  1496.                 }
  1497.             }

  1499.             // Valida il connettore.
  1500.             Connettore conn = is.getConnettore();
  1501.             if (conn != null)
  1502.                 this.validaConnettore(conn, "servizio applicativo ["+idServizioApplicativo+"] (invocazione servizio)", sogg);
  1503.                 
  1504.             // Valida GestioneErrore
  1505.             GestioneErrore ge = is.getGestioneErrore();
  1506.             if (ge != null)
  1507.                 this.validaGestioneErrore(ge, "servizio applicativo ["+idServizioApplicativo+"] (invocazione servizio)");

  1509.             boolean connettore = false;
  1510.             boolean get = false;
  1511.             if(is.getConnettore()!=null && !CostantiConfigurazione.DISABILITATO.equals(is.getConnettore().getTipo())){
  1512.                 connettore = true;
  1513.             }
  1514.             if(is.getGetMessage()!=null && CostantiConfigurazione.ABILITATO.equals(is.getGetMessage())){
  1515.                 get = true;
  1516.             }
  1517.             if(!connettore && !get){
  1518.                 this.errori.add("Il servizio Applicativo "+idServizioApplicativo+" possiede un elemento invocazione servizio per cui non e' stato definito ne una consegna trasparente (tramite connettore) ne il servizio di message box (tramite IntegrationManager)");
  1519.             }
  1520.             
  1521.                         
  1522.             // XSD: get-message: abilitato, disabilitato
  1523.             StatoFunzionalita getMsg = is.getGetMessage();
  1524.             if ((getMsg != null) && !getMsg.equals(CostantiConfigurazione.ABILITATO) && !getMsg.equals(CostantiConfigurazione.DISABILITATO))
  1525.                 this.errori.add("Il get-message dell'invocazione servizio del servizio applicativo "+idServizioApplicativo+" deve assumere i valori: "+
  1526.                         CostantiConfigurazione.ABILITATO+" o "+CostantiConfigurazione.DISABILITATO);

  1528.             // XSD: invio-per-riferimento: abilitato, disabilitato
  1529.             StatoFunzionalita invRif = is.getInvioPerRiferimento();
  1530.             if ((invRif != null) && !invRif.equals(CostantiConfigurazione.ABILITATO) && !invRif.equals(CostantiConfigurazione.DISABILITATO))
  1531.                 this.errori.add("La funzionalita' di invio per riferimento dell'invocazione servizio del servizio applicativo "+idServizioApplicativo+" deve assumere i valori: "+
  1532.                         CostantiConfigurazione.ABILITATO+" o "+CostantiConfigurazione.DISABILITATO);
  1533.             
  1534.             // XSD: risposta-per-riferimento: abilitato, disabilitato
  1535.             StatoFunzionalita rispRif = is.getRispostaPerRiferimento();
  1536.             if ((rispRif != null) && !rispRif.equals(CostantiConfigurazione.ABILITATO) && !rispRif.equals(CostantiConfigurazione.DISABILITATO))
  1537.                 this.errori.add("La funzionalita' di risposta per riferimento dell'invocazione servizio del servizio applicativo "+idServizioApplicativo+" deve assumere i valori: "+
  1538.                         CostantiConfigurazione.ABILITATO+" o "+CostantiConfigurazione.DISABILITATO);

  1540.             // XSD: sbustamento-soap: abilitato, disabilitato
  1541.             StatoFunzionalita sbustamentoSOAP = is.getSbustamentoSoap();
  1542.             if ((sbustamentoSOAP != null) && !sbustamentoSOAP.equals(CostantiConfigurazione.ABILITATO) && !sbustamentoSOAP.equals(CostantiConfigurazione.DISABILITATO))
  1543.                 this.errori.add("L'indicazione di sbustamento SOAP dell'invocazione servizio del servizio applicativo ["+idServizioApplicativo+"] deve assumere i valori: "+
  1544.                         CostantiConfigurazione.ABILITATO+" o "+CostantiConfigurazione.DISABILITATO);
  1545.             
  1546.             // XSD: sbustamento-informazioni-protocollo: abilitato, disabilitato
  1547.             StatoFunzionalita sbustamentoInfoProtocollo = is.getSbustamentoInformazioniProtocollo();
  1548.             if ((sbustamentoInfoProtocollo != null) && !sbustamentoInfoProtocollo.equals(CostantiConfigurazione.ABILITATO) && !sbustamentoInfoProtocollo.equals(CostantiConfigurazione.DISABILITATO))
  1549.                 this.errori.add("L'indicazione di sbustamento informazioni di protcollo dell'invocazione servizio del servizio applicativo ["+idServizioApplicativo+"] deve assumere i valori: "+
  1550.                         CostantiConfigurazione.ABILITATO+" o "+CostantiConfigurazione.DISABILITATO);
  1551.             
  1552.         }

  1554.         // RispostaAsincrona
  1555.         if (sa.getRispostaAsincrona() != null) {
  1556.             
  1557.             RispostaAsincrona ra = sa.getRispostaAsincrona();
  1558.             
  1559.             // Valida Credenziali
  1560.             InvocazioneCredenziali c = ra.getCredenziali();
  1561.             if (c != null)
  1562.                 this.validaCredenziale(c, "servizio applicativo ["+idServizioApplicativo+"] (risposta asincrona)");
  1563.                 
  1564.             // Autenticazione
  1565.             // XSD: autenticazione: basic, ssl, none
  1566.             InvocazioneServizioTipoAutenticazione auth = ra.getAutenticazione();
  1567.             if ((auth != null) && !auth.equals(CostantiConfigurazione.INVOCAZIONE_SERVIZIO_AUTENTICAZIONE_BASIC) && 
  1568.                     !auth.equals(CostantiConfigurazione.INVOCAZIONE_SERVIZIO_AUTENTICAZIONE_NONE))
  1569.                 this.errori.add("L'autenticazione della risposta asincrona del servizio applicativo "+idServizioApplicativo+" deve assumere uno dei seguenti valori: "+
  1570.                         CostantiConfigurazione.INVOCAZIONE_SERVIZIO_AUTENTICAZIONE_BASIC.toString()+" o "+CostantiConfigurazione.INVOCAZIONE_SERVIZIO_AUTENTICAZIONE_NONE.toString());
  1571.             if(CostantiConfigurazione.INVOCAZIONE_SERVIZIO_AUTENTICAZIONE_BASIC.equals(auth)){
  1572.                 if(c==null){
  1573.                     this.errori.add("L'autenticazione "+CostantiConfigurazione.INVOCAZIONE_SERVIZIO_AUTENTICAZIONE_BASIC+" della risposta asincrona del servizio applicativo "+idServizioApplicativo+" richiede la presenza di credenziali");
  1574.                 }
  1575.             }

  1577.             // Valida il connettore.
  1578.             Connettore conn = ra.getConnettore();
  1579.             if (conn != null)
  1580.                 this.validaConnettore(conn, "servizio applicativo ["+idServizioApplicativo+"] (risposta asincrona)", sogg);
  1581.                 
  1582.             // Valida GestioneErrore
  1583.             GestioneErrore ge = ra.getGestioneErrore();
  1584.             if (ge != null)
  1585.                 this.validaGestioneErrore(ge, "servizio applicativo ["+idServizioApplicativo+"] (risposta asincrona)");

  1587.             boolean connettore = false;
  1588.             boolean get = false;
  1589.             if(ra.getConnettore()!=null && !CostantiConfigurazione.DISABILITATO.equals(ra.getConnettore().getTipo())){
  1590.                 connettore = true;
  1591.             }
  1592.             if(ra.getGetMessage()!=null && CostantiConfigurazione.ABILITATO.equals(ra.getGetMessage())){
  1593.                 get = true;
  1594.             }
  1595.             if(!connettore && !get){
  1596.                 this.errori.add("Il servizio Applicativo "+idServizioApplicativo+" possiede un elemento risposta asincrona per cui non e' stato definito ne una consegna trasparente (tramite connettore) ne il servizio di message box (tramite IntegrationManager)");
  1597.             }
  1598.             
  1599.                         
  1600.             // XSD: get-message: abilitato, disabilitato
  1601.             StatoFunzionalita getMsg = ra.getGetMessage();
  1602.             if ((getMsg != null) && !getMsg.equals(CostantiConfigurazione.ABILITATO) && !getMsg.equals(CostantiConfigurazione.DISABILITATO))
  1603.                 this.errori.add("Il get-message della risposta asincrona del servizio applicativo "+idServizioApplicativo+" deve assumere i valori: "+
  1604.                         CostantiConfigurazione.ABILITATO+" o "+CostantiConfigurazione.DISABILITATO);

  1606.             // XSD: invio-per-riferimento: abilitato, disabilitato
  1607.             StatoFunzionalita invRif = ra.getInvioPerRiferimento();
  1608.             if ((invRif != null) && !invRif.equals(CostantiConfigurazione.ABILITATO) && !invRif.equals(CostantiConfigurazione.DISABILITATO))
  1609.                 this.errori.add("La funzionalita' di invio per riferimento della risposta asincrona del servizio applicativo "+idServizioApplicativo+" deve assumere i valori: "+
  1610.                         CostantiConfigurazione.ABILITATO+" o "+CostantiConfigurazione.DISABILITATO);
  1611.             
  1612.             // XSD: risposta-per-riferimento: abilitato, disabilitato
  1613.             StatoFunzionalita rispRif = ra.getRispostaPerRiferimento();
  1614.             if ((rispRif != null) && !rispRif.equals(CostantiConfigurazione.ABILITATO) && !rispRif.equals(CostantiConfigurazione.DISABILITATO))
  1615.                 this.errori.add("La funzionalita' di risposta per riferimento della risposta asincrona del servizio applicativo "+idServizioApplicativo+" deve assumere i valori: "+
  1616.                         CostantiConfigurazione.ABILITATO+" o "+CostantiConfigurazione.DISABILITATO);

  1618.             // XSD: sbustamento-soap: abilitato, disabilitato
  1619.             StatoFunzionalita sbustamentoSOAP = ra.getSbustamentoSoap();
  1620.             if ((sbustamentoSOAP != null) && !sbustamentoSOAP.equals(CostantiConfigurazione.ABILITATO) && !sbustamentoSOAP.equals(CostantiConfigurazione.DISABILITATO))
  1621.                 this.errori.add("L'indicazione di sbustamento SOAP della risposta asincrona del servizio applicativo ["+idServizioApplicativo+"] deve assumere i valori: "+
  1622.                         CostantiConfigurazione.ABILITATO+" o "+CostantiConfigurazione.DISABILITATO);
  1623.             
  1624.             // XSD: sbustamento-informazioni-protocollo: abilitato, disabilitato
  1625.             StatoFunzionalita sbustamentoInfoProtocollo = ra.getSbustamentoInformazioniProtocollo();
  1626.             if ((sbustamentoInfoProtocollo != null) && !sbustamentoInfoProtocollo.equals(CostantiConfigurazione.ABILITATO) && !sbustamentoInfoProtocollo.equals(CostantiConfigurazione.DISABILITATO))
  1627.                 this.errori.add("L'indicazione di sbustamento informazioni di protcollo della risposta asincrona del servizio applicativo ["+idServizioApplicativo+"] deve assumere i valori: "+
  1628.                         CostantiConfigurazione.ABILITATO+" o "+CostantiConfigurazione.DISABILITATO);
  1629.             
  1630.         }

  1632.         // UNICITA: i servizi applicativi definiti nella radice del soggetto devono possedere un nome univoco
  1633.         int numSA = 0;
  1634.         for (int j=0; j<sogg.sizeServizioApplicativoList(); j++) {
  1635.             ServizioApplicativo tmpSA = sogg.getServizioApplicativo(j);
  1636.             if (sa.getNome().equals(tmpSA.getNome())){
  1637.                 numSA++;
  1638.             }
  1639.         }
  1640.         if (numSA > 1)
  1641.             this.errori.add("Non può esistere più di un servizio applicativo con nome "+sa.getNome()+" associato al soggetto "+sogg.getTipo()+"/"+sogg.getNome());
  1642.     }

  1644.     private  void validaConnettore(Connettore conn, String identificativoElementoInternoSoggetto, Soggetto soggetto) throws DriverConfigurazioneException {

  1646.         // Valida il connettore
  1647.         // 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.
  1648.         // 1. i connettori definiti nella radice del registro devono possedere un nome univoco
  1649.         // 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.
  1650.         // 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.
  1651.         // 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.
  1652.         // 5. Se il connettore e' di tipo 'disabilitato' non deve possedere property

  1654.         String nomeConn = conn.getNome();
  1655.         String tipoConn = conn.getTipo();

  1657.         String idSoggetto = soggetto.getTipo()+"/"+soggetto.getNome();
  1658.         
  1659.         // required
  1660.         if(nomeConn==null){
  1661.             if(identificativoElementoInternoSoggetto==null)
  1662.                 this.errori.add("Esiste un connettore nella radice del soggetto["+idSoggetto+"] per cui non è definito il nome");
  1663.             else
  1664.                 this.errori.add("Esiste un connettore del "+identificativoElementoInternoSoggetto+" (Soggetto:"+idSoggetto+") per cui non è definito il nome");
  1665.             return;
  1666.         }

  1668.         if(identificativoElementoInternoSoggetto==null){

  1670.             // 1. i connettori definiti nella radice del soggetto devono possedere un nome univoco
  1671.             int numC = 0;
  1672.             for(int j=0; j<soggetto.sizeConnettoreList();j++){
  1673.                 Connettore tmpC = soggetto.getConnettore(j);
  1674.                 if (nomeConn.equals(tmpC.getNome()))
  1675.                     numC++;
  1676.             }
  1677.             if (numC > 1)
  1678.                 this.errori.add("Non può esistere più di un connettore con nome "+nomeConn+" definito come elemento radice del soggetto["+idSoggetto+"]");
  1679.         }

  1681.         else{
  1682.             if (tipoConn == null) {
  1683.                 // Cerco il connettore nella root del registro
  1684.                 conn = null;
  1685.                 for (int j=0; j<soggetto.sizeConnettoreList();j++) {
  1686.                     Connettore connettore = soggetto.getConnettore(j);
  1687.                     if (nomeConn.equals(connettore.getNome())) {
  1688.                         conn = connettore;
  1689.                         break;
  1690.                     }
  1691.                 }
  1692.             }
  1693.             if (conn == null)
  1694.                 this.errori.add("Il connettore "+nomeConn+" del "+identificativoElementoInternoSoggetto+" (Soggetto:"+idSoggetto+") non corrisponde a nessuno dei connettori registrati");
  1695.             else {
  1696.                 tipoConn = conn.getTipo();
  1697.             }
  1698.         }

  1700.         // 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.
  1701.         if(this.tipoConnettori.contains(tipoConn)==false){
  1702.             if(identificativoElementoInternoSoggetto==null){
  1703.                 this.errori.add("Il tipo ["+tipoConn+"] del connettore "+nomeConn+", definito nella radice del soggetto["+idSoggetto+"], non è valido (Tipi conosciuti: "+this.getTipoConnettori()+")");
  1704.             }else{
  1705.                 this.errori.add("Il tipo ["+tipoConn+"] del connettore "+nomeConn+" del "+identificativoElementoInternoSoggetto+" (Soggetto:"+idSoggetto+") non è valido (Tipi conosciuti: "+this.getTipoConnettori()+")");
  1706.             }
  1707.         }
  1708.         else{

  1710.             List<Property> cps = conn.getPropertyList();
  1711.             Property[] cpArray = null;
  1712.             if(cps.size()>0){
  1713.                 cpArray = cps.toArray(new Property[cps.size()]); 
  1714.             }
  1715.             if(cpArray!=null){
  1716.                 // Check generale sulle proprietà
  1717.                 for (int j=0; j<cpArray.length;j++) {
  1718.                     Property cp = cpArray[j];
  1719.                     if(cp.getNome()==null){
  1720.                         if(identificativoElementoInternoSoggetto==null){
  1721.                             this.errori.add("Il connettore "+nomeConn+", definito nella radice del soggetto["+idSoggetto+"], possiede una proprietà per cui non è definito il nome");
  1722.                         }else{
  1723.                             this.errori.add("Il connettore "+nomeConn+" del "+identificativoElementoInternoSoggetto+" (Soggetto:"+idSoggetto+") possiede una proprietà per cui non è definito il nome");
  1724.                         }
  1725.                         return;
  1726.                     }
  1727.                     if(cp.getValore()==null){
  1728.                         if(identificativoElementoInternoSoggetto==null){
  1729.                             this.errori.add("Il connettore "+nomeConn+", definito nella radice del soggetto["+idSoggetto+"], possiede una proprietà per cui non è definito il valore");
  1730.                         }else{
  1731.                             this.errori.add("Il connettore "+nomeConn+" del "+identificativoElementoInternoSoggetto+" (Soggetto:"+idSoggetto+") possiede una proprietà per cui non è definito il valore");
  1732.                         }
  1733.                         return;
  1734.                     }
  1735.                 }
  1736.             }

  1738.             // Connettore HTTP
  1739.             if (tipoConn.equals(TipiConnettore.HTTP.getNome())) {
  1740.                 String urlConn = null;
  1741.                 for (int j=0; j<cpArray.length;j++) {
  1742.                     Property cp = cpArray[j];
  1743.                     if (cp.getNome().equals(CostantiDB.CONNETTORE_HTTP_LOCATION)) {
  1744.                         urlConn = cp.getValore();
  1745.                         break;
  1746.                     }
  1747.                 }
  1748.                 if (urlConn == null){
  1749.                     if(identificativoElementoInternoSoggetto==null){
  1750.                         this.errori.add("Il connettore "+nomeConn+", definito nella radice del soggetto["+idSoggetto+"], è di tipo http, ma non ha una url definita");
  1751.                     }else{
  1752.                         this.errori.add("Il connettore "+nomeConn+" del "+identificativoElementoInternoSoggetto+" (Soggetto:"+idSoggetto+") è di tipo http, ma non ha una url definita");
  1753.                     }
  1754.                 }
  1755.                 else{
  1756.                     try{
  1757.                         RegExpUtilities.validateUrl(urlConn, true);
  1758.                     }catch(Exception e){
  1759.                         if(identificativoElementoInternoSoggetto==null){
  1760.                             this.errori.add("Il connettore "+nomeConn+", definito nella radice del soggetto["+idSoggetto+"], è di tipo http, ma non ha una url valida: "+e.getMessage());
  1761.                         }else{
  1762.                             this.errori.add("Il connettore "+nomeConn+" del "+identificativoElementoInternoSoggetto+" (Soggetto:"+idSoggetto+") è di tipo http, ma non ha una url valida: "+e.getMessage());
  1763.                         }
  1764.                     }
  1765.                 }
  1766.             }

  1768.             // Connettore JMS
  1769.             else if (tipoConn.equals(TipiConnettore.JMS.getNome())) {
  1770.                 String jmsNome = null, jmsTipo = null, jmsConnFact = null, jmsSendAs = null;
  1771.                 for (int j=0; j<cpArray.length;j++) {
  1772.                     Property cp = cpArray[j];
  1773.                     if (cp.getNome().equals(CostantiDB.CONNETTORE_JMS_NOME))
  1774.                         jmsNome = cp.getValore();
  1775.                     else if (cp.getNome().equals(CostantiDB.CONNETTORE_JMS_TIPO))
  1776.                         jmsTipo = cp.getValore();
  1777.                     else if (cp.getNome().equals(CostantiDB.CONNETTORE_JMS_CONNECTION_FACTORY))
  1778.                         jmsConnFact = cp.getValore();
  1779.                     else if (cp.getNome().equals(CostantiDB.CONNETTORE_JMS_SEND_AS))
  1780.                         jmsSendAs = cp.getValore();
  1781.                 }
  1782.                 if (jmsNome == null){
  1783.                     if(identificativoElementoInternoSoggetto==null){
  1784.                         this.errori.add("Il connettore "+nomeConn+", definito nella radice del soggetto["+idSoggetto+"], è di tipo jms, ma non ha un nome coda/topic definito");
  1785.                     }else{
  1786.                         this.errori.add("Il connettore "+nomeConn+" del "+identificativoElementoInternoSoggetto+" (Soggetto:"+idSoggetto+") è di tipo jms, ma non ha un nome coda/topic definito");
  1787.                     }
  1788.                 }
  1789.                 if (jmsTipo == null){
  1790.                     if(identificativoElementoInternoSoggetto==null){
  1791.                         this.errori.add("Il connettore "+nomeConn+", definito nella radice del soggetto["+idSoggetto+"], è di tipo jms, ma non ha un tipo coda/topic definito");
  1792.                     }else{
  1793.                         this.errori.add("Il connettore "+nomeConn+" del "+identificativoElementoInternoSoggetto+" (Soggetto:"+idSoggetto+") è di tipo jms, ma non ha un tipo coda/topic definito");
  1794.                     }
  1795.                 }else{
  1796.                     if (!jmsTipo.equals(CostantiConnettori.CONNETTORE_JMS_TIPO_QUEUE) && !jmsTipo.equals(CostantiConnettori.CONNETTORE_JMS_TIPO_TOPIC)){
  1797.                         if(identificativoElementoInternoSoggetto==null){
  1798.                             this.errori.add("Il connettore "+nomeConn+", definito nella radice del soggetto["+idSoggetto+"], è di tipo jms, ma non ha un tipo coda/topic valido (valori assumibili sono topic/queue)");
  1799.                         }else{
  1800.                             this.errori.add("Il connettore "+nomeConn+" del "+identificativoElementoInternoSoggetto+" (Soggetto:"+idSoggetto+") è di tipo jms, ma non ha un tipo coda/topic valido (valori assumibili sono topic/queue)");
  1801.                         }
  1802.                     }
  1803.                 }
  1804.                 if (jmsConnFact == null){
  1805.                     if(identificativoElementoInternoSoggetto==null){
  1806.                         this.errori.add("Il connettore "+nomeConn+", definito nella radice del soggetto["+idSoggetto+"], è di tipo jms, ma non ha una connection factory definita");
  1807.                     }else{
  1808.                         this.errori.add("Il connettore "+nomeConn+" del "+identificativoElementoInternoSoggetto+" (Soggetto:"+idSoggetto+") è di tipo jms, ma non ha una connection factory definita");
  1809.                     }
  1810.                 }
  1811.                 if (jmsSendAs == null){
  1812.                     if(identificativoElementoInternoSoggetto==null){
  1813.                         this.errori.add("Il connettore "+nomeConn+", definito nella radice del soggetto["+idSoggetto+"], è di tipo jms, ma non ha un tipo di messaggio (sendAs) definito");
  1814.                     }else{
  1815.                         this.errori.add("Il connettore "+nomeConn+" del "+identificativoElementoInternoSoggetto+" (Soggetto:"+idSoggetto+") è di tipo jms, ma non ha un tipo di messaggio (sendAs) definito");
  1816.                     }
  1817.                 }else{
  1818.                     if (!jmsSendAs.equals(CostantiConnettori.CONNETTORE_JMS_SEND_AS_TEXT_MESSAGE) && !jmsSendAs.equals(CostantiConnettori.CONNETTORE_JMS_SEND_AS_BYTES_MESSAGE)){
  1819.                         if(identificativoElementoInternoSoggetto==null){
  1820.                             this.errori.add("Il connettore "+nomeConn+", definito nella radice del soggetto["+idSoggetto+"], è di tipo jms, ma non ha un tipo di messaggio (sendAs) (valori assumibili sono TextMessage/BytesMessage)");
  1821.                         }else{
  1822.                             this.errori.add("Il connettore "+nomeConn+" del "+identificativoElementoInternoSoggetto+" (Soggetto:"+idSoggetto+") è di tipo jms, ma non ha un tipo di messaggio (sendAs) (valori assumibili sono TextMessage/BytesMessage)");
  1823.                         }
  1824.                     }
  1825.                 }
  1826.             }

  1828.             // Connettore HTTPS
  1829.             else if (tipoConn.equals(TipiConnettore.HTTPS.getNome())) {
  1830.                 String urlConn = null;
  1831.                 String trustStoreLocation = null;
  1832.                 String trustStorePassword = null;
  1833.                 String keyStoreLocation = null;
  1834.                 String keyStorePassword = null;
  1835.                 String keyPassword = null;
  1836.                 String hostNameVerifier = null;
  1837.                 for (int j=0; j<cpArray.length;j++) {
  1838.                     Property cp = cpArray[j];
  1839.                     if (cp.getNome().equals(CostantiDB.CONNETTORE_HTTPS_LOCATION)) {
  1840.                         urlConn = cp.getValore();
  1841.                     }
  1842.                     else if (cp.getNome().equals(CostantiDB.CONNETTORE_HTTPS_TRUST_STORE_LOCATION)) {
  1843.                         trustStoreLocation = cp.getValore();
  1844.                     }
  1845.                     else if (cp.getNome().equals(CostantiDB.CONNETTORE_HTTPS_TRUST_STORE_PASSWORD)) {
  1846.                         trustStorePassword = cp.getValore();
  1847.                     }
  1848.                     else if (cp.getNome().equals(CostantiDB.CONNETTORE_HTTPS_KEY_STORE_LOCATION)) {
  1849.                         keyStoreLocation = cp.getValore();
  1850.                     }
  1851.                     else if (cp.getNome().equals(CostantiDB.CONNETTORE_HTTPS_KEY_STORE_PASSWORD)) {
  1852.                         keyStorePassword = cp.getValore();
  1853.                     }
  1854.                     else if (cp.getNome().equals(CostantiDB.CONNETTORE_HTTPS_KEY_PASSWORD)) {
  1855.                         keyPassword = cp.getValore();
  1856.                     }
  1857.                     else if (cp.getNome().equals(CostantiDB.CONNETTORE_HTTPS_HOSTNAME_VERIFIER)) {
  1858.                         hostNameVerifier = cp.getValore();
  1859.                     }
  1860.                 }
  1861.                 if (urlConn == null){
  1862.                     if(identificativoElementoInternoSoggetto==null){
  1863.                         this.errori.add("Il connettore "+nomeConn+", definito nella radice del soggetto["+idSoggetto+"], è di tipo http, ma non ha una url definita");
  1864.                     }else{
  1865.                         this.errori.add("Il connettore "+nomeConn+" del "+identificativoElementoInternoSoggetto+" (Soggetto:"+idSoggetto+") è di tipo http, ma non ha una url definita");
  1866.                     }
  1867.                 }
  1868.                 else{
  1869.                     try{
  1870.                         RegExpUtilities.validateUrl(urlConn, true);
  1871.                     }catch(Exception e){
  1872.                         if(identificativoElementoInternoSoggetto==null){
  1873.                             this.errori.add("Il connettore "+nomeConn+", definito nella radice del soggetto["+idSoggetto+"], è di tipo http, ma non ha una url valida: "+e.getMessage());
  1874.                         }else{
  1875.                             this.errori.add("Il connettore "+nomeConn+" del "+identificativoElementoInternoSoggetto+" (Soggetto:"+idSoggetto+") è di tipo http, ma non ha una url valida: "+e.getMessage());
  1876.                         }
  1877.                     }
  1878.                 }
  1879.                 if (trustStoreLocation != null){
  1880.                     File f = new File(trustStoreLocation);
  1881.                     if(f.exists()==false){
  1882.                         if(identificativoElementoInternoSoggetto==null){
  1883.                             this.errori.add("Il connettore "+nomeConn+", definito nella radice del soggetto["+idSoggetto+"], definisce un truststore "+trustStoreLocation+" che non esiste");
  1884.                         }else{
  1885.                             this.errori.add("Il connettore "+nomeConn+" del "+identificativoElementoInternoSoggetto+" (Soggetto:"+idSoggetto+") definisce un truststore "+trustStoreLocation+" che non esiste");
  1886.                         }
  1887.                     }
  1888.                     else if(f.isFile()==false){
  1889.                         if(identificativoElementoInternoSoggetto==null){
  1890.                             this.errori.add("Il connettore "+nomeConn+", definito nella radice del soggetto["+idSoggetto+"], definisce un truststore "+trustStoreLocation+" che non e' un file");
  1891.                         }else{
  1892.                             this.errori.add("Il connettore "+nomeConn+" del "+identificativoElementoInternoSoggetto+" (Soggetto:"+idSoggetto+") definisce un truststore "+trustStoreLocation+" che non e' un file");
  1893.                         }
  1894.                     }
  1895.                     else if(f.canRead()==false){
  1896.                         if(identificativoElementoInternoSoggetto==null){
  1897.                             this.errori.add("Il connettore "+nomeConn+", definito nella radice del soggetto["+idSoggetto+"], definisce un truststore "+trustStoreLocation+" che non e' accessibile (permessi in lettura non forniti)");
  1898.                         }else{
  1899.                             this.errori.add("Il connettore "+nomeConn+" del "+identificativoElementoInternoSoggetto+" (Soggetto:"+idSoggetto+") definisce un truststore "+trustStoreLocation+" che non e' accessibile (permessi in lettura non forniti)");
  1900.                         }
  1901.                     }
  1902.                     else if(trustStorePassword==null){
  1903.                         if(identificativoElementoInternoSoggetto==null){
  1904.                             this.errori.add("Il connettore "+nomeConn+", definito nella radice del soggetto["+idSoggetto+"], definisce un truststore "+trustStoreLocation+" per cui non e' stata specificata una password");
  1905.                         }else{
  1906.                             this.errori.add("Il connettore "+nomeConn+" del "+identificativoElementoInternoSoggetto+" (Soggetto:"+idSoggetto+") definisce un truststore "+trustStoreLocation+" per cui non e' stata specificata una password");
  1907.                         }
  1908.                     }
  1909.                 }
  1910.                 if (keyStoreLocation != null){
  1911.                     File f = new File(keyStoreLocation);
  1912.                     if(f.exists()==false){
  1913.                         if(identificativoElementoInternoSoggetto==null){
  1914.                             this.errori.add("Il connettore "+nomeConn+", definito nella radice del soggetto["+idSoggetto+"], definisce un keystore "+keyStoreLocation+" che non esiste");
  1915.                         }else{
  1916.                             this.errori.add("Il connettore "+nomeConn+" del "+identificativoElementoInternoSoggetto+" (Soggetto:"+idSoggetto+") definisce un keystore "+keyStoreLocation+" che non esiste");
  1917.                         }
  1918.                     }
  1919.                     else if(f.isFile()==false){
  1920.                         if(identificativoElementoInternoSoggetto==null){
  1921.                             this.errori.add("Il connettore "+nomeConn+", definito nella radice del soggetto["+idSoggetto+"], definisce un keystore "+keyStoreLocation+" che non e' un file");
  1922.                         }else{
  1923.                             this.errori.add("Il connettore "+nomeConn+" del "+identificativoElementoInternoSoggetto+" (Soggetto:"+idSoggetto+") definisce un keystore "+keyStoreLocation+" che non e' un file");
  1924.                         }
  1925.                     }
  1926.                     else if(f.canRead()==false){
  1927.                         if(identificativoElementoInternoSoggetto==null){
  1928.                             this.errori.add("Il connettore "+nomeConn+", definito nella radice del soggetto["+idSoggetto+"], definisce un keystore "+keyStoreLocation+" che non e' accessibile (permessi in lettura non forniti)");
  1929.                         }else{
  1930.                             this.errori.add("Il connettore "+nomeConn+" del "+identificativoElementoInternoSoggetto+" (Soggetto:"+idSoggetto+") definisce un keystore "+keyStoreLocation+" che non e' accessibile (permessi in lettura non forniti)");
  1931.                         }
  1932.                     }
  1933.                     else if(keyStorePassword==null){
  1934.                         if(identificativoElementoInternoSoggetto==null){
  1935.                             this.errori.add("Il connettore "+nomeConn+", definito nella radice del soggetto["+idSoggetto+"], definisce un keystore "+keyStoreLocation+" per cui non e' stata specificata una password");
  1936.                         }else{
  1937.                             this.errori.add("Il connettore "+nomeConn+" del "+identificativoElementoInternoSoggetto+" (Soggetto:"+idSoggetto+") definisce un keystore "+keyStoreLocation+" per cui non e' stata specificata una password");
  1938.                         }
  1939.                     }
  1940.                     else if(keyPassword==null){
  1941.                         if(identificativoElementoInternoSoggetto==null){
  1942.                             this.errori.add("Il connettore "+nomeConn+", definito nella radice del soggetto["+idSoggetto+"], definisce un keystore "+keyStoreLocation+" per cui non e' stata specificata una password per la chiave privata");
  1943.                         }else{
  1944.                             this.errori.add("Il connettore "+nomeConn+" del "+identificativoElementoInternoSoggetto+" (Soggetto:"+idSoggetto+") definisce un keystore "+keyStoreLocation+" per cui non e' stata specificata una password per la chiave privata");
  1945.                         }
  1946.                     }
  1947.                 }
  1948.                 if(hostNameVerifier!=null){
  1949.                     try{
  1950.                         Boolean.parseBoolean(hostNameVerifier);
  1951.                     }catch(Exception e){
  1952.                         if(identificativoElementoInternoSoggetto==null){
  1953.                             this.errori.add("Il connettore "+nomeConn+", definito nella radice del soggetto["+idSoggetto+"], associa un valore non valido  alla proprieta' 'hostNameVerifier'; valori utilizzabili: true e false");
  1954.                         }else{
  1955.                             this.errori.add("Il connettore "+nomeConn+" del "+identificativoElementoInternoSoggetto+" (Soggetto:"+idSoggetto+") associa un valore non valido  alla proprieta' 'hostNameVerifier'; valori utilizzabili: true e false");
  1956.                         }
  1957.                     }
  1958.                 }
  1959.             }
  1960.             
  1961.             else if (tipoConn.equals(TipiConnettore.DISABILITATO.getNome())) {
  1962.                 if (cpArray != null) {
  1963.                     if(identificativoElementoInternoSoggetto==null){
  1964.                         this.errori.add("Il connettore "+nomeConn+", definito nella radice del soggetto["+idSoggetto+"], è di tipo disabilitato, ma ha delle properties definite");
  1965.                     }else{
  1966.                         this.errori.add("Il connettore "+nomeConn+" del "+identificativoElementoInternoSoggetto+" (Soggetto:"+idSoggetto+") è di tipo disabilitato, ma ha delle properties definite");
  1967.                     }
  1968.                 }
  1969.             }
  1970.         }
  1971.     }

  1973.     private void validaCorrelazioneApplicativaRichiesta(String identificativoRisorsa,CorrelazioneApplicativa ca,boolean portaDelegata) throws DriverConfigurazioneException{
  1974.         // UNICITA: i nomi definiti nella correlazione devono possedere un nome univoco. Puo' esistere anche UN SOLO elemento senza nome
  1975.         // Se identificazione='urlBased' o 'contentBased' il pattern e' obbligatorio.
  1976.         if (ca != null) {
  1977.             
  1978.             // Scadenza
  1979.             if(ca.getScadenza()!=null){
  1980.                 try{
  1981.                     Long.parseLong(ca.getScadenza());
  1982.                 }catch(Exception e){
  1983.                     this.errori.add("Il valore associato alla scadenza della correlazione applicativa inserita nella "+identificativoRisorsa+" dev'essere un numero intero");
  1984.                 }
  1985.             }
  1986.             
  1987.             // Minimo numero di elementi
  1988.             if(ca.sizeElementoList()<1){
  1989.                 this.errori.add(identificativoRisorsa+" che possiede la definizione di una correlazione applicativa senza elementi?");
  1990.             }
  1991.             
  1992.             // Controllo che l'elemento null, equivalga solo all'ultimo elemento della configurazione
  1993.             for (int j=0; j<ca.sizeElementoList();j++) {
  1994.                 CorrelazioneApplicativaElemento cae = ca.getElemento(j);
  1995.                 if(cae.getNome()==null && j!=(ca.sizeElementoList()-1)){
  1996.                     this.errori.add(identificativoRisorsa+" che possiede la definizione di una correlazione applicativa ("+(j+1)+") con un elemento '*' (match qualsiasi contenuto) definito non come ultima regola di correlazione");
  1997.                 }
  1998.             }
  1999.             
  2000.             // Elementi
  2001.             for (int j=0; j<ca.sizeElementoList();j++) {
  2002.                 CorrelazioneApplicativaElemento cae = ca.getElemento(j);
  2003.                 int numE = 0;
  2004.                 for(int k=0; k<ca.sizeElementoList();k++){
  2005.                     CorrelazioneApplicativaElemento tmpCae = ca.getElemento(k);
  2006.                     if(cae.getNome()==null){
  2007.                         if(tmpCae.getNome()==null)
  2008.                             numE++;
  2009.                     }else{
  2010.                         if ((cae.getNome()).equals(tmpCae.getNome()))
  2011.                             numE++;
  2012.                     }
  2013.                 }
  2014.                 if (numE > 1){
  2015.                     String nome = "*";
  2016.                     if(cae.getNome()!=null){
  2017.                         nome = cae.getNome();
  2018.                     }
  2019.                     this.errori.add("Non può esistere più di un elemento di correlazione applicativa con nome "+nome+ " ("+identificativoRisorsa+")");
  2020.                 }
  2021.                 
  2022.                 CorrelazioneApplicativaRichiestaIdentificazione identificazione = cae.getIdentificazione();
  2023.                 if ((identificazione != null) && !identificazione.equals(CostantiConfigurazione.CORRELAZIONE_APPLICATIVA_RICHIESTA_DISABILITATO) && 
  2024.                         !identificazione.equals(CostantiConfigurazione.CORRELAZIONE_APPLICATIVA_RICHIESTA_URL_BASED) && 
  2025.                         !identificazione.equals(CostantiConfigurazione.CORRELAZIONE_APPLICATIVA_RICHIESTA_CONTENT_BASED) && 
  2026.                         !identificazione.equals(CostantiConfigurazione.CORRELAZIONE_APPLICATIVA_RICHIESTA_INPUT_BASED) && 
  2027.                         !identificazione.equals(CostantiConfigurazione.CORRELAZIONE_APPLICATIVA_RICHIESTA_HEADER_BASED) && 
  2028.                         !identificazione.equals(CostantiConfigurazione.CORRELAZIONE_APPLICATIVA_RICHIESTA_TEMPLATE) && 
  2029.                         !identificazione.equals(CostantiConfigurazione.CORRELAZIONE_APPLICATIVA_RICHIESTA_FREEMARKER_TEMPLATE) && 
  2030.                         !identificazione.equals(CostantiConfigurazione.CORRELAZIONE_APPLICATIVA_RICHIESTA_VELOCITY_TEMPLATE)){
  2031.                     this.errori.add("La modalita d'identificazione della correlazione applicativa ("+(j+1)+") nella "+identificativoRisorsa+" deve assumere uno dei seguente valori: "+
  2032.                             CostantiConfigurazione.CORRELAZIONE_APPLICATIVA_RICHIESTA_DISABILITATO+","+
  2033.                             CostantiConfigurazione.CORRELAZIONE_APPLICATIVA_RICHIESTA_URL_BASED+","+
  2034.                             CostantiConfigurazione.CORRELAZIONE_APPLICATIVA_RICHIESTA_CONTENT_BASED+" o "+
  2035.                             CostantiConfigurazione.CORRELAZIONE_APPLICATIVA_RICHIESTA_INPUT_BASED+" o "+
  2036.                             CostantiConfigurazione.CORRELAZIONE_APPLICATIVA_RICHIESTA_HEADER_BASED+" o "+
  2037.                             CostantiConfigurazione.CORRELAZIONE_APPLICATIVA_RICHIESTA_TEMPLATE+" o "+
  2038.                             CostantiConfigurazione.CORRELAZIONE_APPLICATIVA_RICHIESTA_FREEMARKER_TEMPLATE+" o "+
  2039.                             CostantiConfigurazione.CORRELAZIONE_APPLICATIVA_RICHIESTA_VELOCITY_TEMPLATE);
  2040.                 }
  2041.                 if(identificazione==null){
  2042.                     identificazione = CostantiConfigurazione.CORRELAZIONE_APPLICATIVA_RICHIESTA_CONTENT_BASED;
  2043.                 }
  2044.                 
  2045.                 if(CostantiConfigurazione.CORRELAZIONE_APPLICATIVA_RICHIESTA_URL_BASED.equals(identificazione) || CostantiConfigurazione.CORRELAZIONE_APPLICATIVA_RICHIESTA_CONTENT_BASED.equals(identificazione)){
  2046.                     if (cae.getPattern() == null)
  2047.                         this.errori.add("La correlazione applicativa ("+(j+1)+") della "+identificativoRisorsa+" non contiene la definizione del pattern, nonostante la modalita' di identificazione sia "+identificazione);
  2048.                 }   
  2049.                 
  2050.                 CorrelazioneApplicativaGestioneIdentificazioneFallita identificazioneFallita = cae.getIdentificazioneFallita();
  2051.                 if ((identificazioneFallita != null) && !identificazioneFallita.equals(CostantiConfigurazione.BLOCCA) && 
  2052.                         !identificazioneFallita.equals(CostantiConfigurazione.ACCETTA)){
  2053.                     this.errori.add("Il comportamento in caso di identificazione fallita della correlazione applicativa ("+(j+1)+") nella "+identificativoRisorsa+" deve assumere uno dei seguente valori: "+
  2054.                             CostantiConfigurazione.BLOCCA+" o "+
  2055.                             CostantiConfigurazione.ACCETTA);
  2056.                 }
  2057.                 
  2058.                 StatoFunzionalita riusoIdentificatore = cae.getRiusoIdentificativo();
  2059.                 if ((riusoIdentificatore != null) && !riusoIdentificatore.equals(CostantiConfigurazione.ABILITATO) && 
  2060.                         !riusoIdentificatore.equals(CostantiConfigurazione.DISABILITATO)){
  2061.                     this.errori.add("Il comportamento per il riuso dell'id della correlazione applicativa ("+(j+1)+") nella "+identificativoRisorsa+" deve assumere uno dei seguente valori: "+
  2062.                             CostantiConfigurazione.ABILITATO+" o "+
  2063.                             CostantiConfigurazione.DISABILITATO);
  2064.                 }
  2065.                 
  2066.                 
  2067.             }
  2068.         }
  2069.     }
  2070.     
  2071.     private void validaCorrelazioneApplicativaRisposta(String identificativoRisorsa,CorrelazioneApplicativaRisposta ca,boolean portaDelegata) throws DriverConfigurazioneException{
  2072.         // UNICITA: i nomi definiti nella correlazione devono possedere un nome univoco. Puo' esistere anche UN SOLO elemento senza nome
  2073.         // Se identificazione='urlBased' o 'contentBased' il pattern e' obbligatorio.
  2074.         if (ca != null) {
  2075.             
  2076.             // Minimo numero di elementi
  2077.             if(ca.sizeElementoList()<1){
  2078.                 this.errori.add(identificativoRisorsa+" che possiede la definizione di una correlazione applicativa senza elementi?");
  2079.             }
  2080.             
  2081.             // Controllo che l'elemento null, equivalga solo all'ultimo elemento della configurazione
  2082.             for (int j=0; j<ca.sizeElementoList();j++) {
  2083.                 CorrelazioneApplicativaRispostaElemento cae = ca.getElemento(j);
  2084.                 if(cae.getNome()==null && j!=(ca.sizeElementoList()-1)){
  2085.                     this.errori.add(identificativoRisorsa+" che possiede la definizione di una correlazione applicativa ("+(j+1)+") con un elemento '*' (match qualsiasi contenuto) definito non come ultima regola di correlazione");
  2086.                 }
  2087.             }
  2088.             
  2089.             // Elementi
  2090.             for (int j=0; j<ca.sizeElementoList();j++) {
  2091.                 CorrelazioneApplicativaRispostaElemento cae = ca.getElemento(j);
  2092.                 int numE = 0;
  2093.                 for(int k=0; k<ca.sizeElementoList();k++){
  2094.                     CorrelazioneApplicativaRispostaElemento tmpCae = ca.getElemento(k);
  2095.                     if(cae.getNome()==null){
  2096.                         if(tmpCae.getNome()==null)
  2097.                             numE++;
  2098.                     }else{
  2099.                         if ((cae.getNome()).equals(tmpCae.getNome()))
  2100.                             numE++;
  2101.                     }
  2102.                 }
  2103.                 if (numE > 1){
  2104.                     String nome = "*";
  2105.                     if(cae.getNome()!=null){
  2106.                         nome = cae.getNome();
  2107.                     }
  2108.                     this.errori.add("Non può esistere più di un elemento di correlazione applicativa con nome "+nome+ " ("+identificativoRisorsa+")");
  2109.                 }
  2110.                 
  2111.                 CorrelazioneApplicativaRispostaIdentificazione identificazione = cae.getIdentificazione();
  2112.                 if ((identificazione != null) && !identificazione.equals(CostantiConfigurazione.CORRELAZIONE_APPLICATIVA_RISPOSTA_DISABILITATO)  && 
  2113.                         !identificazione.equals(CostantiConfigurazione.CORRELAZIONE_APPLICATIVA_RISPOSTA_CONTENT_BASED) && 
  2114.                         !identificazione.equals(CostantiConfigurazione.CORRELAZIONE_APPLICATIVA_RISPOSTA_INPUT_BASED) && 
  2115.                         !identificazione.equals(CostantiConfigurazione.CORRELAZIONE_APPLICATIVA_RISPOSTA_HEADER_BASED) && 
  2116.                         !identificazione.equals(CostantiConfigurazione.CORRELAZIONE_APPLICATIVA_RISPOSTA_TEMPLATE) && 
  2117.                         !identificazione.equals(CostantiConfigurazione.CORRELAZIONE_APPLICATIVA_RISPOSTA_FREEMARKER_TEMPLATE) && 
  2118.                         !identificazione.equals(CostantiConfigurazione.CORRELAZIONE_APPLICATIVA_RISPOSTA_VELOCITY_TEMPLATE)){
  2119.                     this.errori.add("La modalita d'identificazione della correlazione applicativa ("+(j+1)+") nella "+identificativoRisorsa+" deve assumere uno dei seguente valori: "+
  2120.                             CostantiConfigurazione.CORRELAZIONE_APPLICATIVA_RISPOSTA_DISABILITATO+","+
  2121.                             CostantiConfigurazione.CORRELAZIONE_APPLICATIVA_RISPOSTA_CONTENT_BASED+" o "+
  2122.                             CostantiConfigurazione.CORRELAZIONE_APPLICATIVA_RISPOSTA_INPUT_BASED+" o "+
  2123.                             CostantiConfigurazione.CORRELAZIONE_APPLICATIVA_RISPOSTA_HEADER_BASED+" o "+
  2124.                             CostantiConfigurazione.CORRELAZIONE_APPLICATIVA_RISPOSTA_TEMPLATE+" o "+
  2125.                             CostantiConfigurazione.CORRELAZIONE_APPLICATIVA_RISPOSTA_FREEMARKER_TEMPLATE+" o "+
  2126.                             CostantiConfigurazione.CORRELAZIONE_APPLICATIVA_RISPOSTA_VELOCITY_TEMPLATE);
  2127.                 }
  2128.                 if(identificazione==null){
  2129.                     identificazione = CostantiConfigurazione.CORRELAZIONE_APPLICATIVA_RISPOSTA_CONTENT_BASED;
  2130.                 }
  2131.                 
  2132.                 if(CostantiConfigurazione.CORRELAZIONE_APPLICATIVA_RISPOSTA_CONTENT_BASED.equals(identificazione)){
  2133.                     if (cae.getPattern() == null)
  2134.                         this.errori.add("La correlazione applicativa ("+(j+1)+") della "+identificativoRisorsa+" non contiene la definizione del pattern, nonostante la modalita' di identificazione sia "+identificazione);
  2135.                 }   
  2136.                 
  2137.                 CorrelazioneApplicativaGestioneIdentificazioneFallita identificazioneFallita = cae.getIdentificazioneFallita();
  2138.                 if ((identificazioneFallita != null) && !identificazioneFallita.equals(CostantiConfigurazione.BLOCCA) && 
  2139.                         !identificazioneFallita.equals(CostantiConfigurazione.ACCETTA)){
  2140.                     this.errori.add("Il comportamento in caso di identificazione fallita della correlazione applicativa ("+(j+1)+") nella "+identificativoRisorsa+" deve assumere uno dei seguente valori: "+
  2141.                             CostantiConfigurazione.BLOCCA+" o "+
  2142.                             CostantiConfigurazione.ACCETTA);
  2143.                 }
  2144.                 
  2145.             }
  2146.         }
  2147.     }
  2148.     
  2149.     private void validaConfigurazione(Configurazione configurazione) throws DriverConfigurazioneException {
  2150.         
  2151.         // 1.  Valida accesso registro
  2152.         // Ogni registro deve avere un nome univoco.
  2153.         AccessoRegistro ar = null;
  2154.         if(configurazione.getAccessoRegistro()==null){
  2155.             this.errori.add("Non è stato configurato un accesso ad un registro dei servizi");
  2156.         }else{
  2157.             ar = configurazione.getAccessoRegistro();
  2158.             if(ar.sizeRegistroList()<=0){
  2159.                 this.errori.add("Non è stato configurato un accesso ad un registro dei servizi");
  2160.                 ar = null;
  2161.             }else{
  2162.                 for (int j=0; j<ar.sizeRegistroList(); j++) {
  2163.                     AccessoRegistroRegistro arr = ar.getRegistro(j);
  2164.                     String nomeArr = arr.getNome();
  2165.                     
  2166.                     // required
  2167.                     if(nomeArr==null){
  2168.                         this.errori.add("E' presente la configurazione di accesso ad un registro dei servizi anonimo; deve obbligatoriamente essere associato un nome ad un registro dei servizi");
  2169.                     }
  2170.                     else{
  2171.                         int numAR = 0;
  2172.                         for(int k=0; k<ar.sizeRegistroList();k++){
  2173.                             AccessoRegistroRegistro tmpArr = ar.getRegistro(k);
  2174.                             if (nomeArr.equals(tmpArr.getNome()))
  2175.                                 numAR++;
  2176.                         }
  2177.                         if (numAR > 1)
  2178.                             this.errori.add("Non può esistere più di un registro dei servizi con nome "+nomeArr);
  2179.                     }

  2181.                     // XSD: tipo: xml, uddi, web, db, ws
  2182.                     RegistroTipo tipo = arr.getTipo();
  2183.                     if ((tipo != null) && !tipo.equals(CostantiConfigurazione.REGISTRO_XML) && 
  2184.                             !tipo.equals(CostantiConfigurazione.REGISTRO_UDDI) && 
  2185.                             !tipo.equals(CostantiConfigurazione.REGISTRO_WEB) && 
  2186.                             !tipo.equals(CostantiConfigurazione.REGISTRO_DB) && 
  2187.                             !tipo.equals(CostantiConfigurazione.REGISTRO_WS))
  2188.                         this.errori.add("Il tipo del registro "+nomeArr+" non è valido; deve assumere uno dei seguenti tipi: "+CostantiConfigurazione.REGISTRO_XML.toString()+","+
  2189.                                 CostantiConfigurazione.REGISTRO_UDDI.toString()+","+CostantiConfigurazione.REGISTRO_WEB.toString()+","+CostantiConfigurazione.REGISTRO_DB.toString()+","+
  2190.                                 CostantiConfigurazione.REGISTRO_WS.toString());
  2191.                     
  2192.                     // required
  2193.                     if(arr.getLocation()==null){
  2194.                         this.errori.add("Per la configurazione di accesso al registro dei servizi ["+nomeArr+"] non è stata fornita la location");
  2195.                     }
  2196.                     
  2197.                     // User e Password
  2198.                     if(arr.getPassword()!=null && arr.getUser()==null){
  2199.                         this.errori.add("Per la configurazione di accesso al registro dei servizi ["+nomeArr+"] non è stata fornito un username, ma è stato specificata una password?");
  2200.                     }
  2201.                 }

  2203.                 Cache arc = ar.getCache();
  2204.                 if (arc != null) {
  2205.                     
  2206.                     validaCache(arc, "Registro dei Servizi");
  2207.                     
  2208.                 }
  2209.             }
  2210.         }
  2211.         
  2212.         


  2215.         // 2.  Valida routing table
  2216.         // Ogni destinazione deve possedere un tipo/nome univoco.
  2217.         // Le rotte hanno i seguenti vincoli:
  2218.         // Registro.
  2219.         // Il nome di un registro (se presente) deve essere uno tra i registro definiti nella sezione AccessoRegistro.
  2220.         // Le rotte di tipo registro vengono identificate dal nome (dove il nome non presente e' il caso particolare registro NULL).
  2221.         // Ogni registro deve possedere un nome univoco
  2222.         // Gateway.
  2223.         // Ogni tipo/nome deve essere univoco.
  2224.         RoutingTable rt = configurazione.getRoutingTable();
  2225.         if (rt != null) {
  2226.             
  2227.             // Rotta di default
  2228.             if(rt.getDefault()==null){
  2229.                 this.errori.add("(RoutingTable abilitata) Non è stata definita una rotta di default");
  2230.             }
  2231.             else if(rt.getDefault().sizeRouteList()==0){
  2232.                 this.errori.add("(RoutingTable abilitata) Non è stata definita una rotta tra quelle di default");
  2233.             }
  2234.             else{
  2235.                 RoutingTableDefault rtDefault = rt.getDefault();
  2236.                 for(int i=0; i<rtDefault.sizeRouteList(); i++){
  2237.                     Route r = rtDefault.getRoute(i);
  2238.                     this.validaRotta(r, "[RottaDefault]", ar);
  2239.                     
  2240.                     if(r.getRegistro()!=null){
  2241.                         // Controllo diversita' delle rotte di default
  2242.                         int numRR = 0;
  2243.                         for(int h=0; h<rtDefault.sizeRouteList();h++){
  2244.                             Route tmpR = rtDefault.getRoute(h);
  2245.                             if(tmpR.getRegistro()!=null){
  2246.                                 RouteRegistro tmpRR = tmpR.getRegistro();
  2247.                                 if(r.getRegistro().getNome()==null){
  2248.                                     if(tmpRR.getNome()==null)
  2249.                                         numRR++;
  2250.                                 }else{
  2251.                                     if (r.getRegistro().getNome().equals(tmpRR.getNome()))
  2252.                                         numRR++;
  2253.                                 }
  2254.                             }
  2255.                         }
  2256.                         if (numRR > 1){
  2257.                             String nome = "TuttiRegistri";
  2258.                             if(r.getRegistro().getNome()!=null)
  2259.                                 nome = r.getRegistro().getNome();
  2260.                             this.errori.add("(RoutingTableAbilitata) Non può esistere più di una rotta di default, che utilizzi il registro "+nome);
  2261.                         }
  2262.                     }
  2263.                     
  2264.                     if(r.getGateway()!=null && r.getGateway().getTipo()!=null && r.getGateway().getNome()!=null){
  2265.                         // Controllo diversita' delle rotte di tipo gateway
  2266.                         RouteGateway rg = r.getGateway();
  2267.                         String idRG = rg.getTipo()+"/"+rg.getNome();
  2268.                         int numRG = 0;
  2269.                         for(int h=0; h<rtDefault.sizeRouteList();h++){
  2270.                             Route tmpR = rtDefault.getRoute(h);
  2271.                             if(tmpR.getGateway()!=null && tmpR.getGateway().getTipo()!=null && tmpR.getGateway().getNome()!=null) {
  2272.                                 RouteGateway tmpRG = tmpR.getGateway();
  2273.                                 String tmpIdRG = tmpRG.getTipo()+"/"+tmpRG.getNome();
  2274.                                 if (idRG.equals(tmpIdRG))
  2275.                                     numRG++;
  2276.                             }
  2277.                         }
  2278.                         if (numRG > 1)
  2279.                             this.errori.add("(RoutingTableAbilitata) Non può esistere più di una rotta di default di tipo gateway con identificativo soggetto "+idRG);
  2280.                     }
  2281.                 }
  2282.             }
  2283.             
  2284.             // Destinazioni statiche
  2285.             for (int j=0; j<rt.sizeDestinazioneList(); j++) {
  2286.                 RoutingTableDestinazione rtd = rt.getDestinazione(j);
  2287.                 
  2288.                 // required
  2289.                 if(rtd.getTipo()==null){
  2290.                     this.errori.add("(RoutingTable abilitata) E' stata definita una rotta di destinazone statica, senza aver specificato il tipo");
  2291.                 }
  2292.                 else if(rtd.getNome()==null){
  2293.                     this.errori.add("(RoutingTable abilitata) E' stata definita una rotta di destinazone statica, senza aver specificato il nome");
  2294.                 }
  2295.                 else{
  2296.                     
  2297.                     String idDest = rtd.getTipo()+"/"+rtd.getNome();
  2298.                     
  2299.                     // Verifico che non esista piu' di una rotta statica con stesso id
  2300.                     int numD = 0;
  2301.                     for(int k=0; k<rt.sizeDestinazioneList();k++){
  2302.                         RoutingTableDestinazione tmpRtd = rt.getDestinazione(k);
  2303.                         String tmpIdDest = tmpRtd.getTipo()+"/"+tmpRtd.getNome();
  2304.                         if (idDest.equals(tmpIdDest))
  2305.                             numD++;
  2306.                     }
  2307.                     if (numD > 1)
  2308.                         this.errori.add("(RoutingTable abilitata)  Non può esistere più di una rotta di destinazione statico con identificativo soggetto"+idDest);
  2309.                     
  2310.                     // Verifico rotte presenti nella destinazione statica
  2311.                     for(int k=0; k<rtd.sizeRouteList();k++){
  2312.                         Route r = rtd.getRoute(k);
  2313.                     
  2314.                         // Valida rotta
  2315.                         this.validaRotta(r, "[RottaDestinazioneStatica("+idDest+")]", ar);

  2317.                         if(r.getRegistro()!=null){
  2318.                             // Controllo diversita' delle rotte di destinazione statica per questo soggetto
  2319.                             int numRR = 0;
  2320.                             for(int h=0; h<rtd.sizeRouteList();h++){
  2321.                                 Route tmpR = rtd.getRoute(h);
  2322.                                 if(tmpR.getRegistro()!=null){
  2323.                                     RouteRegistro tmpRR = tmpR.getRegistro();
  2324.                                     if(r.getRegistro().getNome()==null){
  2325.                                         if(tmpRR.getNome()==null)
  2326.                                             numRR++;
  2327.                                     }else{
  2328.                                         if (r.getRegistro().getNome().equals(tmpRR.getNome()))
  2329.                                             numRR++;
  2330.                                     }
  2331.                                 }
  2332.                             }
  2333.                             if (numRR > 1){
  2334.                                 String nome = "TuttiRegistri";
  2335.                                 if(r.getRegistro().getNome()!=null)
  2336.                                     nome = r.getRegistro().getNome();
  2337.                                 this.errori.add("(RoutingTableAbilitata) Non può esistere più di una rotta per la destinazione statica ["+idDest+"], che utilizzi il registro "+nome);
  2338.                             }
  2339.                         }
  2340.                         
  2341.                         if(r.getGateway()!=null && r.getGateway().getTipo()!=null && r.getGateway().getNome()!=null){
  2342.                             // Controllo diversita' delle rotte di tipo gateway
  2343.                             RouteGateway rg = r.getGateway();
  2344.                             String idRG = rg.getTipo()+"/"+rg.getNome();
  2345.                             int numRG = 0;
  2346.                             for(int h=0; h<rtd.sizeRouteList();h++){
  2347.                                 Route tmpR = rtd.getRoute(h);
  2348.                                 if(tmpR.getGateway()!=null && tmpR.getGateway().getTipo()!=null && tmpR.getGateway().getNome()!=null) {
  2349.                                     RouteGateway tmpRG = tmpR.getGateway();
  2350.                                     String tmpIdRG = tmpRG.getTipo()+"/"+tmpRG.getNome();
  2351.                                     if (idRG.equals(tmpIdRG))
  2352.                                         numRG++;
  2353.                                 }
  2354.                             }
  2355.                             if (numRG > 1)
  2356.                                 this.errori.add("(RoutingTableAbilitata) Non può esistere più di una rotta per la destinazione statica ["+idDest+"] di tipo gateway con identificativo soggetto "+idRG);
  2357.                         }
  2358.                     }
  2359.                     
  2360.                 }
  2361.             }
  2362.         }

  2364.         
  2365.         // Validazione Accesso Configurazione
  2366.         if(configurazione.getAccessoConfigurazione()!=null){
  2367.             if(configurazione.getAccessoConfigurazione().getCache()!=null){
  2368.                 this.validaCache(configurazione.getAccessoConfigurazione().getCache(), "ConfigurazionePdD");
  2369.             }
  2370.         }
  2371.         
  2372.         // Validazione Dati Accesso Autorizzazione
  2373.         if(configurazione.getAccessoDatiAutorizzazione()!=null){
  2374.             if(configurazione.getAccessoDatiAutorizzazione().getCache()!=null){
  2375.                 this.validaCache(configurazione.getAccessoDatiAutorizzazione().getCache(), "DatiAutorizzazione");
  2376.             }
  2377.         }
  2378.         
  2379.         
  2380.         // ValidazioneBuste
  2381.         ValidazioneBuste vbe = configurazione.getValidazioneBuste();
  2382.         if (vbe != null) {
  2383.             // XSD: stato: abilitato, disabilitato, warningOnly
  2384.             StatoFunzionalitaConWarning statoBuste = vbe.getStato();
  2385.             if ((statoBuste != null) && !statoBuste.equals(CostantiConfigurazione.STATO_CON_WARNING_ABILITATO) && 
  2386.                     !statoBuste.equals(CostantiConfigurazione.STATO_CON_WARNING_DISABILITATO) && 
  2387.                     !statoBuste.equals(CostantiConfigurazione.STATO_CON_WARNING_WARNING_ONLY))
  2388.                 this.errori.add("Lo stato della validazione buste deve possedere uno dei seguenti valori: "+CostantiConfigurazione.STATO_CON_WARNING_ABILITATO+
  2389.                         ", "+CostantiConfigurazione.STATO_CON_WARNING_DISABILITATO+
  2390.                         " o "+CostantiConfigurazione.STATO_CON_WARNING_WARNING_ONLY);

  2392.             // XSD: controllo: normale, rigido
  2393.             ValidazioneBusteTipoControllo controllo = vbe.getControllo();
  2394.             if ((controllo != null) && !controllo.equals(CostantiConfigurazione.VALIDAZIONE_PROTOCOL_LIVELLO_NORMALE) && 
  2395.                     !controllo.equals(CostantiConfigurazione.VALIDAZIONE_PROTOCOL_LIVELLO_RIGIDO))
  2396.                 this.errori.add("Il controllo della validazione buste deve possedere uno dei seguenti valori: "+CostantiConfigurazione.VALIDAZIONE_PROTOCOL_LIVELLO_NORMALE+
  2397.                         " o "+CostantiConfigurazione.VALIDAZIONE_PROTOCOL_LIVELLO_RIGIDO);

  2399.             // XSD: profilo-collaborazione: abilitato, disabilitato
  2400.             StatoFunzionalita profColl = vbe.getProfiloCollaborazione();
  2401.             if ((profColl != null) && !profColl.equals(CostantiConfigurazione.ABILITATO) && !profColl.equals(CostantiConfigurazione.DISABILITATO))
  2402.                 this.errori.add("Il profilo di collaborazione della validazione buste deve possedere i valori "+CostantiConfigurazione.ABILITATO+
  2403.                         " o "+CostantiConfigurazione.DISABILITATO);

  2405.             // XSD: manifest-attachments: abilitato, disabilitato
  2406.             StatoFunzionalita manifest = vbe.getManifestAttachments();
  2407.             if ((manifest != null) && !manifest.equals("abilitato") && !manifest.equals("disabilitato"))
  2408.                 this.errori.add("Il manifest-attachments della validazione buste deve possedere i valori "+CostantiConfigurazione.ABILITATO+
  2409.                         " o "+CostantiConfigurazione.DISABILITATO);
  2410.         }
  2411.     
  2412.         
  2413.         // ValidazioneContenutiApplicativi
  2414.         if(configurazione.getValidazioneContenutiApplicativi()!=null)
  2415.             this.validazioneValidazioneContenutiApplicativi(configurazione.getValidazioneContenutiApplicativi(),"ConfigurazioneGeneralePdD");
  2416.         
  2417.     
  2418.         // Indirizzo Telematico
  2419.         IndirizzoRisposta it = configurazione.getIndirizzoRisposta();
  2420.         if (it != null) {
  2421.             // XSD: utilizzo: abilitato, disabilitato
  2422.             StatoFunzionalita utilizzo = it.getUtilizzo();
  2423.             if ((utilizzo != null) && !utilizzo.equals(CostantiConfigurazione.ABILITATO) && !utilizzo.equals(CostantiConfigurazione.DISABILITATO))
  2424.                 this.errori.add("L'utilizzo dell'indirizzo per la risposta nella configurazione generale della PdD deve assumere i valori: "+
  2425.                         CostantiConfigurazione.ABILITATO+" o "+CostantiConfigurazione.DISABILITATO);
  2426.         }
  2427.         
  2428.         // Attachments
  2429.         Attachments attachments = configurazione.getAttachments();
  2430.         if (attachments != null) {
  2431.             // XSD: utilizzo: abilitato, disabilitato
  2432.             StatoFunzionalita gestione = attachments.getGestioneManifest();
  2433.             if ((gestione != null) && !gestione.equals(CostantiConfigurazione.ABILITATO) && !gestione.equals(CostantiConfigurazione.DISABILITATO))
  2434.                 this.errori.add("La gestione dei manifest degli attachments nella configurazione generale della PdD deve assumere i valori: "+
  2435.                         CostantiConfigurazione.ABILITATO+" o "+CostantiConfigurazione.DISABILITATO);
  2436.         }
  2437.         
  2438.         // Risposte
  2439.         Risposte rs = configurazione.getRisposte();
  2440.         if (rs != null) {
  2441.             // XSD: connessione: new, reply
  2442.             TipoConnessioneRisposte connessione = rs.getConnessione();
  2443.             if ((connessione != null) && !connessione.equals(CostantiConfigurazione.NEW_CONNECTION) && !connessione.equals(CostantiConfigurazione.CONNECTION_REPLY))
  2444.                 this.errori.add("La connessione delle risposte nella configurazione generale della PdD deve assumere i valori:"+
  2445.                         CostantiConfigurazione.CONNECTION_REPLY+" o "+CostantiConfigurazione.NEW_CONNECTION);
  2446.         }
  2447.         
  2448.         
  2449.         // Inoltro Buste non riscontrate
  2450.         if(configurazione.getInoltroBusteNonRiscontrate()==null){
  2451.             this.errori.add("Definizione della cadenza delle buste non riscontrate non presente nella configurazione generale della PdD");
  2452.         }else{
  2453.             InoltroBusteNonRiscontrate inoltro = configurazione.getInoltroBusteNonRiscontrate();
  2454.             if(inoltro.getCadenza()==null){
  2455.                 this.errori.add("Definizione della cadenza delle buste non riscontrate non presente nella configurazione generale della PdD");
  2456.             }else{
  2457.                 try{
  2458.                     Long.parseLong(inoltro.getCadenza());
  2459.                 }catch(Exception e){
  2460.                     this.errori.add("Il valore associato alla cadenza delle buste non riscontrate, presente nella configurazione generale della PdD, dev'essere un numero intero");
  2461.                 }
  2462.             }
  2463.         }
  2464.         
  2465.         
  2466.         
  2467.         // 3.  Valida mssaggi diagnostici
  2468.         // Ogni elemento definito nelle proprieta' di un OpenSPCoopProperties deve avere un nome univoco.
  2469.         MessaggiDiagnostici md = configurazione.getMessaggiDiagnostici();
  2470.         if (md != null) {
  2471.             for (int j=0; j<md.sizeOpenspcoopAppenderList(); j++) {
  2472.                 OpenspcoopAppender oa = md.getOpenspcoopAppender(j);
  2473.                 
  2474.                 // Controllo tipo
  2475.                 if(oa.getTipo()==null){
  2476.                     this.errori.add("E' stato definito un appender dei msg diagnostici per cui non e' stato definito il tipo");
  2477.                 }
  2478.                 else {
  2479.                     
  2480.                     // Controllo tipo
  2481.                     if(this.tipoMsgDiagnosticiAppender.contains(oa.getTipo())==false){
  2482.                         this.errori.add("E' stato definito un appender dei msg diagnostici per cui e' stato definito un tipo["+oa.getTipo()+"] non valido, valori ammessi sono: "+this.getTipoMsgDiagnosticiAppender());
  2483.                     }
  2484.                     
  2485.                     for(int k=0; k<oa.sizePropertyList();k++){
  2486.                         Property oap = oa.getProperty(k);
  2487.                         
  2488.                         if(oap.getNome()==null){
  2489.                             
  2490.                         }
  2491.                         else if(oap.getValore()==null){
  2492.                             this.errori.add("E' stato definito un appender["+oa.getTipo()+"] dei msg diagnostici per cui esiste una proprieta' senza un valore?");
  2493.                         }
  2494.                         else{
  2495.                             // Controllo univocita' nome
  2496.                             String nomeOap = oap.getNome();
  2497.                             int numOap = 0;
  2498.                             for(int h=0; h<oa.sizePropertyList();h++){
  2499.                                 Property tmpOap = oa.getProperty(h);
  2500.                                 if (nomeOap.equals(tmpOap.getNome()))
  2501.                                     numOap++;
  2502.                             }
  2503.                             if (numOap > 1)
  2504.                                 this.errori.add("Non può esistere più di una proprietà con nome "+nomeOap +" per lo stesso appender["+oa.getTipo()+"] dei msg diagnostici");
  2505.                         }
  2506.                     }
  2507.                 }
  2508.                 
  2509.             }

  2511.             // XSD:: off, fatal, errorProtocol, errorIntegration, infoProtocol, infoIntegration, debugLow, debugMedium, debugHigh, all
  2512.             Severita severita = md.getSeverita();
  2513.             if ((severita != null) && !severita.equals(Severita.OFF) && !severita.equals(Severita.FATAL) && 
  2514.                     !severita.equals(Severita.ERROR_PROTOCOL) && !severita.equals(Severita.ERROR_INTEGRATION) && 
  2515.                     !severita.equals(Severita.INFO_PROTOCOL) && !severita.equals(Severita.INFO_INTEGRATION) && 
  2516.                     !severita.equals(Severita.DEBUG_LOW) && !severita.equals(Severita.DEBUG_MEDIUM) && !severita.equals(Severita.DEBUG_HIGH) &&
  2517.                     !severita.equals(Severita.ALL))
  2518.                 this.errori.add("L'opzione 'severita' della configurazione dei messaggi diagnostici nella configurazione generale della PdD deve assumere uno dei seguenti valori: off, fatal, errorProtocol, errorIntegration, infoProtocol, infoIntegration, debugLow, debugMedium, debugHigh, all");

  2520.             // XSD: openspcoop: off, fatal, errorProtocol, errorIntegration, infoProtocol, infoIntegration, debugLow, debugMedium, debugHigh, all
  2521.             Severita severitaLog4j = md.getSeveritaLog4j();
  2522.             if ((severitaLog4j != null) && !severitaLog4j.equals(Severita.OFF) && !severitaLog4j.equals(Severita.FATAL) && 
  2523.                     !severitaLog4j.equals(Severita.ERROR_PROTOCOL) && !severitaLog4j.equals(Severita.ERROR_INTEGRATION) && 
  2524.                     !severitaLog4j.equals(Severita.INFO_PROTOCOL) && !severitaLog4j.equals(Severita.INFO_INTEGRATION) && 
  2525.                     !severitaLog4j.equals(Severita.DEBUG_LOW) && !severitaLog4j.equals(Severita.DEBUG_MEDIUM) && !severitaLog4j.equals(Severita.DEBUG_HIGH) &&
  2526.                     !severitaLog4j.equals(Severita.ALL))
  2527.             this.errori.add("L'opzione 'severita-log4j' della configurazione dei messaggi diagnostici nella configurazione generale della PdD deve assumere uno dei seguenti valori: off, fatal, errorProtocol, errorIntegration, infoProtocol, infoIntegration, debugLow, debugMedium, debugHigh, all");
  2528.         }
  2529.         else{
  2530.             this.errori.add("Non e' stata definita la configurazione dei messaggi diagnostici nella configurazione generale della PdD");
  2531.         }
  2532.         
  2533.         // 4.  Valida tracciamento
  2534.         // Ogni elemento definito nelle proprieta' di un OpenSPCoopProperties deve avere un nome univoco.
  2535.         Tracciamento t = configurazione.getTracciamento();
  2536.         if (t != null) {
  2537.             for (int j=0; j<t.sizeOpenspcoopAppenderList(); j++) {
  2538.                 OpenspcoopAppender oa = t.getOpenspcoopAppender(j);
  2539.                 
  2540.                 // Controllo tipo
  2541.                 if(oa.getTipo()==null){
  2542.                     this.errori.add("E' stato definito un appender delle tracce per cui non e' stato definito il tipo");
  2543.                 }
  2544.                 else {
  2545.                     
  2546.                     // Controllo tipo
  2547.                     if(this.tipoTracciamentoAppender.contains(oa.getTipo())==false){
  2548.                         this.errori.add("E' stato definito un appender delle tracce per cui e' stato definito un tipo["+oa.getTipo()+"] non valido, valori ammessi sono: "+this.getTipoTracciamentoAppender());
  2549.                     }
  2550.                 
  2551.                     for(int k=0; k<oa.sizePropertyList();k++){
  2552.                         Property oap = oa.getProperty(k);
  2553.                         
  2554.                         if(oap.getNome()==null){
  2555.                             this.errori.add("E' stato definito un appender["+oa.getTipo()+"] delle tracce per cui esiste una proprieta' senza un nome?");
  2556.                         }
  2557.                         else if(oap.getValore()==null){
  2558.                             this.errori.add("E' stato definito un appender["+oa.getTipo()+"] delle tracce per cui esiste una proprieta' senza un valore?");
  2559.                         }
  2560.                         else{
  2561.                             // Controllo univocita' nome
  2562.                             String nomeOap = oap.getNome();
  2563.                             int numOap = 0;
  2564.                             for(int h=0; h<oa.sizePropertyList();h++){
  2565.                                 Property tmpOap = oa.getProperty(h);
  2566.                                 if (nomeOap.equals(tmpOap.getNome()))
  2567.                                     numOap++;
  2568.                             }
  2569.                             if (numOap > 1)
  2570.                                 this.errori.add("Non può esistere più di una proprietà con nome "+nomeOap+" per lo stesso appender["+oa.getTipo()+"] delle tracce");
  2571.                         }
  2572.                     }
  2573.                     
  2574.                 }
  2575.             }

  2577.             // XSD: buste: abilitato, disabilitato
  2578.             StatoFunzionalita tracciamentoBuste = t.getStato();
  2579.             if ((tracciamentoBuste != null) && !tracciamentoBuste.equals(CostantiConfigurazione.ABILITATO) && !tracciamentoBuste.equals(CostantiConfigurazione.DISABILITATO))
  2580.                 this.errori.add("Il valore 'buste' della configurazione per il tracciamento delle buste deve assumere i valori "+CostantiConfigurazione.ABILITATO+
  2581.                         " o "+CostantiConfigurazione.DISABILITATO);

  2583.         }

  2585.         
  2586.         // 5.  Valida dump
  2587.         // Ogni elemento definito nelle proprieta' di un OpenSPCoopProperties deve avere un nome univoco.
  2588.         Dump d = configurazione.getDump();
  2589.         if (d != null) {
  2590.             for (int j=0; j<d.sizeOpenspcoopAppenderList(); j++) {
  2591.                 OpenspcoopAppender oa = d.getOpenspcoopAppender(j);
  2592.                 
  2593.                 // Controllo tipo
  2594.                 if(oa.getTipo()==null){
  2595.                     this.errori.add("E' stato definito un appender del dump per cui non e' stato definito il tipo");
  2596.                 }
  2597.                 else {
  2598.                     
  2599.                     // Controllo tipo
  2600.                     if(this.tipoDumpAppender.contains(oa.getTipo())==false){
  2601.                         this.errori.add("E' stato definito un appender del dump per cui e' stato definito un tipo["+oa.getTipo()+"] non valido, valori ammessi sono: "+this.getTipoDumpAppender());
  2602.                     }
  2603.                 
  2604.                     for(int k=0; k<oa.sizePropertyList();k++){
  2605.                         Property oap = oa.getProperty(k);
  2606.                         
  2607.                         if(oap.getNome()==null){
  2608.                             this.errori.add("E' stato definito un appender["+oa.getTipo()+"] del dump per cui esiste una proprieta' senza un nome?");
  2609.                         }
  2610.                         else if(oap.getValore()==null){
  2611.                             this.errori.add("E' stato definito un appender["+oa.getTipo()+"] del dump per cui esiste una proprieta' senza un valore?");
  2612.                         }
  2613.                         else{
  2614.                             // Controllo univocita' nome
  2615.                             String nomeOap = oap.getNome();
  2616.                             int numOap = 0;
  2617.                             for(int h=0; h<oa.sizePropertyList();h++){
  2618.                                 Property tmpOap = oa.getProperty(h);
  2619.                                 if (nomeOap.equals(tmpOap.getNome()))
  2620.                                     numOap++;
  2621.                             }
  2622.                             if (numOap > 1)
  2623.                                 this.errori.add("Non può esistere più di una proprietà con nome "+nomeOap+" per lo stesso appender["+oa.getTipo()+"] delle tracce");
  2624.                         }
  2625.                     }
  2626.                     
  2627.                 }
  2628.             }

  2630.             // XSD: buste: abilitato, disabilitato
  2631.             StatoFunzionalita statoDump = d.getStato();
  2632.             if ((statoDump != null) && !statoDump.equals(CostantiConfigurazione.ABILITATO) && !statoDump.equals(CostantiConfigurazione.DISABILITATO))
  2633.                 this.errori.add("Il valore 'buste' della configurazione per il tracciamento delle buste deve assumere i valori "+CostantiConfigurazione.ABILITATO+
  2634.                         " o "+CostantiConfigurazione.DISABILITATO);


  2637.         }
  2638.         

  2640.         // Gestione Errore
  2641.         if(configurazione.getGestioneErrore()!=null){
  2642.             if(configurazione.getGestioneErrore().getComponenteCooperazione()!=null){
  2643.                 validaGestioneErrore(configurazione.getGestioneErrore().getComponenteCooperazione(),"ConfigurazioneGenerale-GestioneErroreComponenteCooperazione");
  2644.             }
  2645.             if(configurazione.getGestioneErrore().getComponenteIntegrazione()!=null){
  2646.                 validaGestioneErrore(configurazione.getGestioneErrore().getComponenteIntegrazione(),"ConfigurazioneGenerale-GestioneErroreComponenteIntegrazione");
  2647.             }
  2648.         }
  2649.                 
  2650.         
  2651.         // IntegrationManager
  2652.         IntegrationManager im = configurazione.getIntegrationManager();
  2653.         if (im != null && im.getAutenticazione()!=null){
  2654.             String[]v = im.getAutenticazione().split(",");
  2655.             if(v!=null && v.length>0){
  2656.                 for(int l=0;l<v.length;l++){
  2657.                     if(this.tipoAutenticazionePortaDelegata.contains(v[l].trim())==false){
  2658.                         this.errori.add("Processo di autenticazione["+v[l].trim()+"] associato al servizio di IntegrationManager non conosciuto, valori ammessi: "+this.getTipoAutenticazionePortaDelegata());
  2659.                     }
  2660.                 }
  2661.             }
  2662.         }

  2664.         // Servizi
  2665.         StatoServiziPdd s = configurazione.getStatoServiziPdd();
  2666.         if(s!=null){
  2667.             
  2668.             // PortaDelegata
  2669.             if(s.getPortaDelegata()!=null){
  2670.                 StatoServiziPddPortaDelegata sPD = s.getPortaDelegata();
  2671.                 
  2672.                 StatoFunzionalita portaDelegata = sPD.getStato();
  2673.                 // XSD: abilitato, disabilitato
  2674.                 if ((portaDelegata != null) && !portaDelegata.equals(CostantiConfigurazione.ABILITATO) && !portaDelegata.equals(CostantiConfigurazione.DISABILITATO))
  2675.                     this.errori.add("Il valore 'stato' della configurazione per quanto concerne i servizi attivi sulla porta (PD) deve assumere i valori "+CostantiConfigurazione.ABILITATO+
  2676.                             " o "+CostantiConfigurazione.DISABILITATO);
  2677.                 
  2678.                 validaFiltriStatoServiziPdD("FiltroAbilitazione", sPD.getFiltroAbilitazioneList());
  2679.                 validaFiltriStatoServiziPdD("FiltroDisabilitazione", sPD.getFiltroDisabilitazioneList());
  2680.             }
  2681.             
  2682.             // PortaApplicativa
  2683.             if(s.getPortaApplicativa()!=null){
  2684.                 StatoServiziPddPortaApplicativa sPA = s.getPortaApplicativa();
  2685.                 
  2686.                 StatoFunzionalita portaApplicativa = sPA.getStato();
  2687.                 // XSD: abilitato, disabilitato
  2688.                 if ((portaApplicativa != null) && !portaApplicativa.equals(CostantiConfigurazione.ABILITATO) && !portaApplicativa.equals(CostantiConfigurazione.DISABILITATO))
  2689.                     this.errori.add("Il valore 'porta_applicativa' della configurazione per quanto concerne i servizi attivi sulla porta (PA) deve assumere i valori "+CostantiConfigurazione.ABILITATO+
  2690.                             " o "+CostantiConfigurazione.DISABILITATO);
  2691.                 
  2692.                 validaFiltriStatoServiziPdD("FiltroAbilitazione", sPA.getFiltroAbilitazioneList());
  2693.                 validaFiltriStatoServiziPdD("FiltroDisabilitazione", sPA.getFiltroDisabilitazioneList());
  2694.             }
  2695.             
  2696.             // IntegrationManager
  2697.             if(s.getIntegrationManager()!=null){
  2698.                 StatoServiziPddIntegrationManager sIM = s.getIntegrationManager();
  2699.                 
  2700.                 StatoFunzionalita integrationManager = sIM.getStato();
  2701.                 // XSD: abilitato, disabilitato
  2702.                 if ((integrationManager != null) && !integrationManager.equals(CostantiConfigurazione.ABILITATO) && !integrationManager.equals(CostantiConfigurazione.DISABILITATO))
  2703.                     this.errori.add("Il valore 'integration_manager' della configurazione per quanto concerne i servizi attivi sulla porta (IM) assumere i valori "+CostantiConfigurazione.ABILITATO+
  2704.                             " o "+CostantiConfigurazione.DISABILITATO);
  2705.             }
  2706.             
  2707.         }
  2708.         
  2709.     }

  2711.     private void validaCache(Cache cache, String posizione){
  2712.         // Dimensione
  2713.         if(cache.getDimensione()!=null){
  2714.             try{
  2715.                 Integer.parseInt(cache.getDimensione());
  2716.             }catch(Exception e){
  2717.                 this.errori.add("Il valore associato alla dimensione della cache ["+posizione+"] dev'essere un numero intero");
  2718.             }
  2719.         }
  2720.         
  2721.         // XSD: algoritmo: lru, mru
  2722.         AlgoritmoCache algoritmo = cache.getAlgoritmo();
  2723.         if ((algoritmo != null) && !algoritmo.equals(CostantiConfigurazione.CACHE_LRU) && !algoritmo.equals(CostantiConfigurazione.CACHE_MRU))
  2724.             this.errori.add("L'algoritmo dell'accesso alla cache ["+posizione+"] dev'essere "+CostantiConfigurazione.CACHE_LRU+" o "+CostantiConfigurazione.CACHE_MRU);
  2725.         
  2726.         // ItemIdleTime
  2727.         if(cache.getItemIdleTime()!=null){
  2728.             try{
  2729.                 Long.parseLong(cache.getItemIdleTime());
  2730.             }catch(Exception e){
  2731.                 this.errori.add("Il valore associato all'item-idle-time della cache  ["+posizione+"] dev'essere un numero intero");
  2732.             }
  2733.         }
  2734.         
  2735.         // ItemLifeSecond
  2736.         if(cache.getItemLifeSecond()!=null){
  2737.             try{
  2738.                 Long.parseLong(cache.getItemLifeSecond());
  2739.             }catch(Exception e){
  2740.                 this.errori.add("Il valore associato all'item-life-seconds della cache ["+posizione+"] dev'essere un numero intero");
  2741.             }
  2742.         }
  2743.     }
  2744.     
  2745.     private void validaFiltriStatoServiziPdD(String tipologiaFiltri,List<TipoFiltroAbilitazioneServizi> lista){
  2746.         if(lista!=null){
  2747.             for (int j = 0; j < lista.size(); j++) {
  2748.                 @SuppressWarnings("unused")
  2749.                 TipoFiltroAbilitazioneServizi filtro = lista.get(j);
  2750.                 
  2751. //              if ((filtro.getTipoSoggettoFruitore() != null) && !filtro.getTipoSoggettoFruitore().equals(CostantiConfigurazione.ABILITATO) && !filtro.getTipoSoggettoFruitore().equals(CostantiConfigurazione.DISABILITATO))
  2752. //                  this.errori.add("Il valore 'tipo_soggetto_fruitore' del filtro["+j+"] (tipologia:"+tipologiaFiltri+") della configurazione per quanto concerne  i servizi attivi sulla porta deve assumere i valori "+CostantiConfigurazione.ABILITATO+
  2753. //                          " o "+CostantiConfigurazione.DISABILITATO);
  2754. //              if ((filtro.getSoggettoFruitore() != null) && !filtro.getSoggettoFruitore().equals(CostantiConfigurazione.ABILITATO) && !filtro.getSoggettoFruitore().equals(CostantiConfigurazione.DISABILITATO))
  2755. //                  this.errori.add("Il valore 'soggetto_fruitore' del filtro["+j+"] (tipologia:"+tipologiaFiltri+") della configurazione per quanto concerne  i servizi attivi sulla porta deve assumere i valori "+CostantiConfigurazione.ABILITATO+
  2756. //                          " o "+CostantiConfigurazione.DISABILITATO);
  2757. //              if ((filtro.getIdentificativoPortaFruitore() != null) && !filtro.getIdentificativoPortaFruitore().equals(CostantiConfigurazione.ABILITATO) && !filtro.getIdentificativoPortaFruitore().equals(CostantiConfigurazione.DISABILITATO))
  2758. //                  this.errori.add("Il valore 'identificativo_porta_fruitore' del filtro["+j+"] (tipologia:"+tipologiaFiltri+") della configurazione per quanto concerne  i servizi attivi sulla porta deve assumere i valori "+CostantiConfigurazione.ABILITATO+
  2759. //                          " o "+CostantiConfigurazione.DISABILITATO);
  2760. //              
  2761. //              if ((filtro.getTipoSoggettoErogatore() != null) && !filtro.getTipoSoggettoErogatore().equals(CostantiConfigurazione.ABILITATO) && !filtro.getTipoSoggettoErogatore().equals(CostantiConfigurazione.DISABILITATO))
  2762. //                  this.errori.add("Il valore 'tipo_soggetto_erogatore' del filtro["+j+"] (tipologia:"+tipologiaFiltri+") della configurazione per quanto concerne  i servizi attivi sulla porta deve assumere i valori "+CostantiConfigurazione.ABILITATO+
  2763. //                          " o "+CostantiConfigurazione.DISABILITATO);
  2764. //              if ((filtro.getSoggettoErogatore() != null) && !filtro.getSoggettoErogatore().equals(CostantiConfigurazione.ABILITATO) && !filtro.getSoggettoErogatore().equals(CostantiConfigurazione.DISABILITATO))
  2765. //                  this.errori.add("Il valore 'soggetto_erogatore' del filtro["+j+"] (tipologia:"+tipologiaFiltri+") della configurazione per quanto concerne  i servizi attivi sulla porta deve assumere i valori "+CostantiConfigurazione.ABILITATO+
  2766. //                          " o "+CostantiConfigurazione.DISABILITATO);
  2767. //              if ((filtro.getIdentificativoPortaErogatore() != null) && !filtro.getIdentificativoPortaErogatore().equals(CostantiConfigurazione.ABILITATO) && !filtro.getIdentificativoPortaErogatore().equals(CostantiConfigurazione.DISABILITATO))
  2768. //                  this.errori.add("Il valore 'identificativo_porta_erogatore' del filtro["+j+"] (tipologia:"+tipologiaFiltri+") della configurazione per quanto concerne  i servizi attivi sulla porta deve assumere i valori "+CostantiConfigurazione.ABILITATO+
  2769. //                          " o "+CostantiConfigurazione.DISABILITATO);
  2770. //              
  2771. //              if ((filtro.getTipoServizio() != null) && !filtro.getTipoServizio().equals(CostantiConfigurazione.ABILITATO) && !filtro.getTipoServizio().equals(CostantiConfigurazione.DISABILITATO))
  2772. //                  this.errori.add("Il valore 'tipo_servizio' del filtro["+j+"] (tipologia:"+tipologiaFiltri+") della configurazione per quanto concerne  i servizi attivi sulla porta deve assumere i valori "+CostantiConfigurazione.ABILITATO+
  2773. //                          " o "+CostantiConfigurazione.DISABILITATO);
  2774. //              if ((filtro.getServizio() != null) && !filtro.getServizio().equals(CostantiConfigurazione.ABILITATO) && !filtro.getServizio().equals(CostantiConfigurazione.DISABILITATO))
  2775. //                  this.errori.add("Il valore 'servizio' del filtro["+j+"] (tipologia:"+tipologiaFiltri+") della configurazione per quanto concerne  i servizi attivi sulla porta deve assumere i valori "+CostantiConfigurazione.ABILITATO+
  2776. //                          " o "+CostantiConfigurazione.DISABILITATO);
  2777. //              
  2778. //              if ((filtro.getAzione() != null) && !filtro.getAzione().equals(CostantiConfigurazione.ABILITATO) && !filtro.getAzione().equals(CostantiConfigurazione.DISABILITATO))
  2779. //                  this.errori.add("Il valore 'azione' del filtro["+j+"] (tipologia:"+tipologiaFiltri+") della configurazione per quanto concerne  i servizi attivi sulla porta deve assumere i valori "+CostantiConfigurazione.ABILITATO+
  2780. //                          " o "+CostantiConfigurazione.DISABILITATO);
  2781.             }
  2782.         }
  2783.     }
  2784.     
  2785.     private void validaRotta(Route route,String tipo,AccessoRegistro ar) throws DriverConfigurazioneException{
  2786.         if(route.getGateway()==null && route.getRegistro()==null){
  2787.             this.errori.add("(RoutingTable) è stata definita una rotta "+tipo+" senza aver specificato ne un Gateway ne un Registro");
  2788.         }
  2789.         else if(route.getGateway()!=null && route.getRegistro()!=null){
  2790.             this.errori.add("(RoutingTable) è stata definita una rotta "+tipo+" che possiede sia un Gateway che un Registro (Solo un tipo deve essere selezionato)");
  2791.         }
  2792.         else if(route.getGateway()!=null){
  2793.             if(route.getGateway().getNome()==null){
  2794.                 this.errori.add("(RoutingTable) è stata definita una rotta "+tipo+" senza aver specificato il nome del soggetto Gateway");
  2795.             }
  2796.             if(route.getGateway().getTipo()==null){
  2797.                 this.errori.add("(RoutingTable) è stata definita una rotta "+tipo+" senza aver specificato il tipo del soggetto Gateway");
  2798.             }
  2799.         }else {
  2800.             if(route.getRegistro().getNome()!=null){
  2801.                 if(ar!=null){
  2802.                     // Il nome del registro non è obbligatorio: se non definito equivale a cercare in tutti
  2803.                     boolean trovato = false;
  2804.                     for(int i=0; i<ar.sizeRegistroList();i++){
  2805.                         if (ar.getRegistro(i).getNome().equals(route.getRegistro().getNome())){
  2806.                             trovato = true;
  2807.                             break;
  2808.                         }
  2809.                     }
  2810.                     if(!trovato){
  2811.                         this.errori.add("(RoutingTable) è stata definita una rotta "+tipo+" per cui è stata specificato un registro ["+route.getRegistro().getNome()+"] non esistente neella configurazione");
  2812.                     }
  2813.                 }else{
  2814.                     // errore gestito nella validazione della configurazione di accesso al registro
  2815.                 }
  2816.             }
  2817.         }
  2818.     }
  2819.     
  2820.     private  void validaMessageSecurity(MessageSecurity messageSecurity,String idOggetto) throws DriverConfigurazioneException {
  2821.         // Ogni elemento definito nella RequestFlow deve avere un nome univoco.
  2822.         // Ogni elemento definito nella ResponseFlow deve avere un nome univoco.
  2823.         if(messageSecurity.getRequestFlow()!=null){
  2824.             MessageSecurityFlow messageSecurityFlow = messageSecurity.getRequestFlow();
  2825.             for (int j=0; j<messageSecurityFlow.sizeParameterList();j++) {
  2826.                 MessageSecurityFlowParameter securityParameter = messageSecurityFlow.getParameter(j);
  2827.                 
  2828.                 if(securityParameter.getNome()==null){
  2829.                     this.errori.add("("+idOggetto+" MessageSecurity) Nella request-flow esiste una proprieta' per cui non e' stato definito il nome");
  2830.                 }
  2831.                 if(securityParameter.getValore()==null){
  2832.                     this.errori.add("("+idOggetto+" MessageSecurity) Nella request-flow esiste una proprieta' per cui non e' stato definito il valore");
  2833.                 }
  2834.                 
  2835.                 int numRF = 0;
  2836.                 for(int k=0; k<messageSecurityFlow.sizeParameterList();k++){
  2837.                     MessageSecurityFlowParameter tmpSecurityParameter = messageSecurityFlow.getParameter(k);
  2838.                     if ((securityParameter.getNome()).equals(tmpSecurityParameter.getNome()))
  2839.                         numRF++;
  2840.                 }
  2841.                 if (numRF > 1)
  2842.                     this.errori.add("("+idOggetto+" MessageSecurity) Nella request-flow non può esistere più di una proprieta' con lo stess nome "+securityParameter.getNome());
  2843.             }
  2844.         }
  2845.         if(messageSecurity.getResponseFlow()!=null){
  2846.             MessageSecurityFlow messageSecurityFlow = messageSecurity.getResponseFlow();
  2847.             for (int j=0; j<messageSecurityFlow.sizeParameterList();j++) {
  2848.                 MessageSecurityFlowParameter securityParameter = messageSecurityFlow.getParameter(j);
  2849.                 
  2850.                 if(securityParameter.getNome()==null){
  2851.                     this.errori.add("("+idOggetto+" MessageSecurity) Nella response-flow esiste una proprieta' per cui non e' stato definito il nome");
  2852.                 }
  2853.                 if(securityParameter.getValore()==null){
  2854.                     this.errori.add("("+idOggetto+" MessageSecurity) Nella response-flow esiste una proprieta' per cui non e' stato definito il valore");
  2855.                 }
  2856.                 
  2857.                 int numRF = 0;
  2858.                 for(int k=0; k<messageSecurityFlow.sizeParameterList();k++){
  2859.                     MessageSecurityFlowParameter tmpSecurityParameter = messageSecurityFlow.getParameter(k);
  2860.                     if ((securityParameter.getNome()).equals(tmpSecurityParameter.getNome()))
  2861.                         numRF++;
  2862.                 }
  2863.                 if (numRF > 1)
  2864.                     this.errori.add("("+idOggetto+" MessageSecurity) Nella response-flow non può esistere più di una proprieta' con lo stess nome "+securityParameter.getNome());
  2865.             }
  2866.         }
  2867.     }
  2868.     
  2869.     private  void validaMTOM(MtomProcessor mtomProcessor,String idOggetto) throws DriverConfigurazioneException {
  2870.         // Ogni elemento definito nella RequestFlow deve avere un nome univoco.
  2871.         // Ogni elemento definito nella ResponseFlow deve avere un nome univoco.
  2872.         if(mtomProcessor.getRequestFlow()!=null){
  2873.             MtomProcessorFlow mtomtFlow = mtomProcessor.getRequestFlow();
  2874.             for (int j=0; j<mtomtFlow.sizeParameterList();j++) {
  2875.                 MtomProcessorFlowParameter mtomtFlowParameter = mtomtFlow.getParameter(j);
  2876.                 
  2877.                 if(mtomtFlowParameter.getNome()==null){
  2878.                     this.errori.add("("+idOggetto+" MTOM-Processor) Nella request-flow esiste una proprieta' per cui non e' stato definito il nome");
  2879.                 }
  2880.                 if(mtomtFlowParameter.getPattern()==null){
  2881.                     this.errori.add("("+idOggetto+" MTOM-Processor) Nella request-flow esiste una proprieta' per cui non e' stato definito il valore");
  2882.                 }
  2883.                 
  2884.                 int numRF = 0;
  2885.                 for(int k=0; k<mtomtFlow.sizeParameterList();k++){
  2886.                     MtomProcessorFlowParameter tmpMtomtFlowParameter = mtomtFlow.getParameter(k);
  2887.                     if ((mtomtFlowParameter.getNome()).equals(tmpMtomtFlowParameter.getNome()))
  2888.                         numRF++;
  2889.                 }
  2890.                 if (numRF > 1)
  2891.                     this.errori.add("("+idOggetto+" MTOM-Processor) Nella request-flow non può esistere più di una proprieta' con lo stess nome "+mtomtFlowParameter.getNome());
  2892.             }
  2893.         }
  2894.         if(mtomProcessor.getResponseFlow()!=null){
  2895.             MtomProcessorFlow mtomFlow = mtomProcessor.getResponseFlow();
  2896.             for (int j=0; j<mtomFlow.sizeParameterList();j++) {
  2897.                 MtomProcessorFlowParameter mtomtFlowParameter = mtomFlow.getParameter(j);
  2898.                 
  2899.                 if(mtomtFlowParameter.getNome()==null){
  2900.                     this.errori.add("("+idOggetto+" MTOM-Processor) Nella response-flow esiste una proprieta' per cui non e' stato definito il nome");
  2901.                 }
  2902.                 if(mtomtFlowParameter.getPattern()==null){
  2903.                     this.errori.add("("+idOggetto+" MTOM-Processor) Nella response-flow esiste una proprieta' per cui non e' stato definito il valore");
  2904.                 }
  2905.                 
  2906.                 int numRF = 0;
  2907.                 for(int k=0; k<mtomFlow.sizeParameterList();k++){
  2908.                     MtomProcessorFlowParameter tmpMtomtFlowParameter = mtomFlow.getParameter(k);
  2909.                     if ((mtomtFlowParameter.getNome()).equals(tmpMtomtFlowParameter.getNome()))
  2910.                         numRF++;
  2911.                 }
  2912.                 if (numRF > 1)
  2913.                     this.errori.add("("+idOggetto+" MTOM-Processor) Nella response-flow non può esistere più di una proprieta' con lo stess nome "+mtomtFlowParameter.getNome());
  2914.             }
  2915.         }
  2916.     }

  2918.     private  void validazioneValidazioneContenutiApplicativi(ValidazioneContenutiApplicativi vca,String tipo) throws DriverConfigurazioneException {
  2919.         // Se stato = disabilitato, il tipo puo' non  essere presente
  2920.         // Se stato = abilitato o warningOnly il tipo deve essere presente con uno dei valori definiti nel xsd
  2921.         StatoFunzionalitaConWarning stato = vca.getStato();
  2922.         if ((stato != null) && !stato.equals(CostantiConfigurazione.STATO_CON_WARNING_ABILITATO) && 
  2923.                 !stato.equals(CostantiConfigurazione.STATO_CON_WARNING_DISABILITATO) && 
  2924.                 !stato.equals(CostantiConfigurazione.STATO_CON_WARNING_WARNING_ONLY))
  2925.             this.errori.add("Lo stato della validazione contenuti applicativi ("+tipo+") deve possedere uno dei seguenti valori: "+CostantiConfigurazione.STATO_CON_WARNING_ABILITATO+
  2926.                     ", "+CostantiConfigurazione.STATO_CON_WARNING_DISABILITATO+
  2927.                     " o "+CostantiConfigurazione.STATO_CON_WARNING_WARNING_ONLY);
  2928.             
  2929.         ValidazioneContenutiApplicativiTipo tipoV = vca.getTipo();
  2930.         // XSD: tipo: wsdl, openspcoop, xsd
  2931.         if ((tipoV != null) && !tipoV.equals(CostantiConfigurazione.VALIDAZIONE_CONTENUTI_APPLICATIVI_OPENSPCOOP) && 
  2932.                 !tipoV.equals(CostantiConfigurazione.VALIDAZIONE_CONTENUTI_APPLICATIVI_INTERFACE) && 
  2933.                 !tipoV.equals(CostantiConfigurazione.VALIDAZIONE_CONTENUTI_APPLICATIVI_XSD))
  2934.             this.errori.add("Il tipo di validazione contenuti applicativi da attuare ("+tipo+") deve possedere uno dei seguenti valori: " +
  2935.                     CostantiConfigurazione.VALIDAZIONE_CONTENUTI_APPLICATIVI_XSD+", "+
  2936.                     CostantiConfigurazione.VALIDAZIONE_CONTENUTI_APPLICATIVI_INTERFACE+" o "+
  2937.                     CostantiConfigurazione.VALIDAZIONE_CONTENUTI_APPLICATIVI_OPENSPCOOP);
  2938.     }

  2940.     private  void validaProtocolProperty(Proprieta ssp, String oggetto) throws DriverConfigurazioneException {
  2941.         // Controlli sui valori definiti nell'xsd.

  2943.         if(ssp.getNome()==null){
  2944.             this.errori.add("Esiste una ProprietaProtocollo della porta "+oggetto+" che non contiene la definizione del nome");
  2945.         }
  2946.         if(ssp.getValore()==null){
  2947.             this.errori.add("Esiste una ProprietaProtocollo della porta "+oggetto+" che non contiene la definizione del valore");
  2948.         }
  2949.         
  2950.         // XSD: valore: mittente, tipoMittente, destinatario, tipoDestinatario, servizio, tipoServizio, azione, identificativo
  2951.         String valore = ssp.getValore();
  2952.         if(valore==null){
  2953.             this.errori.add("Il valore della ProprietaProtocollo "+ssp.getNome()+" della porta applicativa "+oggetto+" non e' valorizzato");
  2954.         }
  2955.         // Il check sopra esclude la possibilita' di avere un qualsiasi valore, possibilita' offerta anche dall'interfaccia grafica
  2956.         /*
  2957.         if ((valore != null) && !valore.equals(ProprietaProtocolloValore.MITTENTE.toString()) && 
  2958.                 !valore.equals(ProprietaProtocolloValore.TIPO_MITTENTE.toString()) && 
  2959.                 !valore.equals(ProprietaProtocolloValore.DESTINATARIO.toString()) && 
  2960.                 !valore.equals(ProprietaProtocolloValore.TIPO_DESTINATARIO.toString()) && 
  2961.                 !valore.equals(ProprietaProtocolloValore.SERVIZIO.toString()) && 
  2962.                 !valore.equals(ProprietaProtocolloValore.TIPO_SERVIZIO.toString()) && 
  2963.                 !valore.equals(ProprietaProtocolloValore.AZIONE.toString()) && 
  2964.                 !valore.equals(ProprietaProtocolloValore.IDENTIFICATIVO.toString()))
  2965.             this.errori.add("Il valore della ProprietaProtocollo "+ssp.getNome()+" della porta applicativa "+oggetto+" dev'essere mittente, tipoMittente, destinatario, tipoDestinatario, servizio, tipoServizio, azione o identificativo");
  2966.             */
  2967.     }

  2969.     private  void validaCredenziale(Credenziali c, String oggetto) throws DriverConfigurazioneException {
  2970.         // Se il tipo e' basic, username e password sono OBBLIGATORI
  2971.         
  2972.         CredenzialeTipo tipo = CostantiConfigurazione.CREDENZIALE_SSL;
  2973.         if(c.getTipo()!=null){
  2974.             tipo = c.getTipo();
  2975.         }
  2976.         if ( !tipo.equals(CostantiConfigurazione.CREDENZIALE_BASIC) && 
  2977.                 !tipo.equals(CostantiConfigurazione.CREDENZIALE_APIKEY) && 
  2978.                 !tipo.equals(CostantiConfigurazione.CREDENZIALE_SSL) && 
  2979.                 !tipo.equals(CostantiConfigurazione.CREDENZIALE_PRINCIPAL) &&
  2980.                 !tipo.equals(CostantiConfigurazione.CREDENZIALE_TOKEN)  )
  2981.             this.errori.add("Il tipo delle credenziali del "+oggetto+" deve possedere i valori: "+
  2982.                 CostantiConfigurazione.CREDENZIALE_BASIC.toString()+" o "+
  2983.                 CostantiConfigurazione.CREDENZIALE_APIKEY.toString()+" o "+
  2984.                     CostantiConfigurazione.CREDENZIALE_SSL.toString()+" o "+
  2985.                     CostantiConfigurazione.CREDENZIALE_PRINCIPAL.toString()+" o "+
  2986.                     CostantiConfigurazione.CREDENZIALE_TOKEN.toString());
  2987.         
  2988.         
  2989.         if (c.getTipo().equals(CostantiConfigurazione.CREDENZIALE_BASIC)) {
  2990.             if ((c.getUser() == null) || (c.getUser().equals("")) || (c.getPassword() == null) || (c.getPassword().equals("")))
  2991.                 this.errori.add("Le credenziali di tipo basic del "+oggetto+" devono avere username e password valorizzati");
  2992.         }
  2993.         if (c.getTipo().equals(CostantiConfigurazione.CREDENZIALE_APIKEY)) {
  2994.             if ((c.getUser() == null) || (c.getUser().equals("")) || (c.getPassword() == null) || (c.getPassword().equals("")))
  2995.                 this.errori.add("Le credenziali di tipo apikey del "+oggetto+" devono avere username e password valorizzati");
  2996.         }

  2998.         // Se il tipo e' ssl, subject e' OBBLIGATORIO
  2999.         if (c.getTipo().equals(CostantiConfigurazione.CREDENZIALE_SSL)){
  3000.             if (
  3001.                     (c.getSubject() == null || c.getSubject().equals(""))
  3002.                     &&
  3003.                     c.getCertificate()==null
  3004.             ){
  3005.                 this.errori.add("Le credenziali di tipo ssl del "+oggetto+" devono avere subject o certificate valorizzato");
  3006.             }else{
  3007.                 if(c.getSubject()!=null && !"".equals(c.getSubject())) {
  3008.                     try{
  3009.                         CertificateUtils.validaPrincipal(c.getSubject(), PrincipalType.SUBJECT);
  3010.                     }catch(Exception e){
  3011.                         this.errori.add("Le credenziali di tipo ssl del "+oggetto+" possiedono un subject non valido: "+e.getMessage());
  3012.                     }
  3013.                 }
  3014.                 if(c.getIssuer()!=null && !"".equals(c.getIssuer())) {
  3015.                     try{
  3016.                         CertificateUtils.validaPrincipal(c.getIssuer(), PrincipalType.ISSUER);
  3017.                     }catch(Exception e){
  3018.                         this.errori.add("Le credenziali di tipo ssl del "+oggetto+" possiedono un issuer non valido: "+e.getMessage());
  3019.                     }
  3020.                 }
  3021.             }
  3022.         }
  3023.             
  3024.         // Se il tipo e' principal, user e' OBBLIGATORIO
  3025.         if (c.getTipo().equals(CostantiConfigurazione.CREDENZIALE_PRINCIPAL)){
  3026.             if ((c.getUser() == null) || (c.getUser().equals(""))){
  3027.                 this.errori.add("Le credenziali di tipo principal del "+oggetto+" devono avere user valorizzato");
  3028.             }
  3029.         }
  3030.         
  3031.         // Se il tipo e' token, user e token_policy e' OBBLIGATORIO
  3032.         if (c.getTipo().equals(CostantiConfigurazione.CREDENZIALE_TOKEN)){
  3033.             if ((c.getUser() == null) || (c.getUser().equals(""))){
  3034.                 this.errori.add("Le credenziali di tipo token del "+oggetto+" devono avere user valorizzato");
  3035.             }
  3036.             if ((c.getTokenPolicy() == null) || (c.getTokenPolicy().equals(""))){
  3037.                 this.errori.add("Le credenziali di tipo token del "+oggetto+" devono avere token-policy valorizzato");
  3038.             }
  3039.         }
  3040.         
  3041.     }
  3042.     
  3043.     private  void validaCredenziale(InvocazioneCredenziali c, String oggetto) throws DriverConfigurazioneException {
  3044.         // Se il tipo e' basic, username e password sono OBBLIGATORI
  3045.         
  3046.         if ((c.getUser() == null) || (c.getUser().equals("")) || (c.getPassword() == null) || (c.getPassword().equals("")))
  3047.             this.errori.add("Le credenziali di tipo basic del "+oggetto+" devono avere username e password valorizzati");
  3048.         
  3049.     }

  3051.     private void validaGestioneErrore(GestioneErrore ge,String tipo) throws DriverConfigurazioneException {
  3052.         
  3053.         // Ogni elemento codice-trasporto DEVE possedere ALMENO o un valore minimo o un valore massimo.
  3054.         for(int j=0; j<ge.sizeCodiceTrasportoList();j++){
  3055.             GestioneErroreCodiceTrasporto gect = ge.getCodiceTrasporto(j);
  3056.             if (gect.getValoreMinimo() == null || gect.getValoreMassimo() == null)
  3057.                 this.errori.add("Gli elementi codice-trasporto devono possedere almeno un valore minimo o un valore massimo");

  3059.             if (gect.getValoreMinimo()!=null && gect.getValoreMinimo().longValue() <0){
  3060.                 this.errori.add("Il valore minimo di un codice-trasporto associato alla gestione errore ("+tipo+"), dev'essere un numero intero >= 0 (Attualemente:"+gect.getValoreMinimo().longValue()+")");
  3061.             }
  3062.             if (gect.getValoreMassimo()!=null && gect.getValoreMassimo().longValue() <=0){
  3063.                 this.errori.add("Il valore massimo di un codice-trasporto associato alla gestione errore ("+tipo+"), dev'essere un numero intero > 0 (Attualemente:"+gect.getValoreMassimo().longValue()+")");
  3064.             }
  3065.             if (gect.getValoreMassimo()!=null && gect.getValoreMinimo().longValue()>=0 && 
  3066.                     gect.getValoreMinimo()!=null && gect.getValoreMassimo().longValue()>0){
  3067.                 if(gect.getValoreMassimo().longValue()<gect.getValoreMinimo().longValue()){
  3068.                     this.errori.add("Il valore massimo di un codice-trasporto associato alla gestione errore ("+tipo+"), dev'essere un numero intero maggiore del valore associate al valore minimo (Attualemente max:"+gect.getValoreMassimo().longValue()+" min:"+gect.getValoreMinimo().longValue()+")");
  3069.                 }
  3070.             }
  3071.             
  3072.             // XSD: comportamento: accetta, rispedisci
  3073.             GestioneErroreComportamento comportamento = gect.getComportamento();
  3074.             if(comportamento==null){
  3075.                 this.errori.add("Non e' stato definito il comportamento di adottato per la gestione errore ("+tipo+") per un codice-trasporto");
  3076.             }else{
  3077.                 if ( !comportamento.equals(CostantiConfigurazione.GESTIONE_ERRORE_ACCETTA_MSG) && !comportamento.equals(CostantiConfigurazione.GESTIONE_ERRORE_RISPEDISCI_MSG))
  3078.                     this.errori.add("Il comportamento associato alla gestione errore ("+tipo+"-CodiceTrasporto) deve assumere uno dei seguenti valori: "+
  3079.                             CostantiConfigurazione.GESTIONE_ERRORE_ACCETTA_MSG+" o "+CostantiConfigurazione.GESTIONE_ERRORE_RISPEDISCI_MSG);
  3080.             }
  3081.             
  3082.             // Cadenza rispedizione
  3083.             if(gect.getCadenzaRispedizione()!=null){
  3084.                 try{
  3085.                     Long.parseLong(gect.getCadenzaRispedizione());
  3086.                 }catch(Exception e){
  3087.                     this.errori.add("Il valore della cadenza di rispedizione associato alla gestione errore ("+tipo+") per un codice-trasporto, dev'essere un numero intero");
  3088.                 }
  3089.             }
  3090.         }

  3092.         // Ogni elemento soap-fault deve essere univoco. L'elemento viene identificato dalla tripla (fault-actor,fault-code,fault-string). In caso alcuni dei tre attributi (anche tutti) non sono definiti, per il controllo di univocita' devono essere considerati come elementi speciali 'NULL'
  3093.         for(int j=0; j<ge.sizeSoapFaultList();j++){
  3094.             
  3095.             GestioneErroreSoapFault gesf = ge.getSoapFault(j);
  3096.             
  3097.             String identificativo = "";
  3098.             if (gesf.getFaultActor() == null)
  3099.                 identificativo = "NULL-";
  3100.             else
  3101.                 identificativo = gesf.getFaultActor()+"-";
  3102.             if (gesf.getFaultCode() == null)
  3103.                 identificativo = identificativo+"NULL-";
  3104.             else
  3105.                 identificativo = identificativo+""+gesf.getFaultCode()+"-";
  3106.             if (gesf.getFaultString() == null)
  3107.                 identificativo = identificativo+"NULL";
  3108.             else
  3109.                 identificativo = identificativo+""+gesf.getFaultString();
  3110.             int numSF = 0;
  3111.             for (int k=0; k<ge.sizeSoapFaultList(); k++) {
  3112.                 GestioneErroreSoapFault tmpGesf = ge.getSoapFault(k);
  3113.                 String tmpId = "";
  3114.                 if (tmpGesf.getFaultActor() == null)
  3115.                     tmpId = "NULL-";
  3116.                 else
  3117.                     tmpId = tmpGesf.getFaultActor()+"-";
  3118.                 if (tmpGesf.getFaultCode() == null)
  3119.                     tmpId = tmpId+"NULL-";
  3120.                 else
  3121.                     tmpId = tmpId+""+tmpGesf.getFaultCode()+"-";
  3122.                 if (tmpGesf.getFaultString() == null)
  3123.                     tmpId = tmpId+"NULL";
  3124.                 else
  3125.                     tmpId = tmpId+""+tmpGesf.getFaultString();
  3126.                 if (identificativo.equals(tmpId))
  3127.                     numSF++;
  3128.             }
  3129.             if (numSF > 1)
  3130.                 this.errori.add("Non può esistere più di un elemento soap-fault con identificativo "+identificativo+" associato alla gestione errore ("+tipo+")");

  3132.             // XSD: comportamento: accetta, rispedisci
  3133.             GestioneErroreComportamento comportamento = gesf.getComportamento();
  3134.             if(comportamento==null){
  3135.                 this.errori.add("Non e' stato definito il comportamento di adottato per la gestione errore ("+tipo+") per un soap-fault");
  3136.             }else{
  3137.                 if ( !comportamento.equals(CostantiConfigurazione.GESTIONE_ERRORE_ACCETTA_MSG) && !comportamento.equals(CostantiConfigurazione.GESTIONE_ERRORE_RISPEDISCI_MSG))
  3138.                     this.errori.add("Il comportamento associato alla gestione errore ("+tipo+"-SoapFault) deve assumere uno dei seguenti valori: "+
  3139.                             CostantiConfigurazione.GESTIONE_ERRORE_ACCETTA_MSG+" o "+CostantiConfigurazione.GESTIONE_ERRORE_RISPEDISCI_MSG);
  3140.             }
  3141.             
  3142.             // Cadenza rispedizione
  3143.             if(gesf.getCadenzaRispedizione()!=null){
  3144.                 try{
  3145.                     Long.parseLong(gesf.getCadenzaRispedizione());
  3146.                 }catch(Exception e){
  3147.                     this.errori.add("Il valore della cadenza di rispedizione associato alla gestione errore ("+tipo+") per un soap-fault, dev'essere un numero intero");
  3148.                 }
  3149.             }
  3150.         }

  3152.         
  3153.         // XSD: comportamento: accetta, rispedisci
  3154.         GestioneErroreComportamento comportamento = ge.getComportamento();
  3155.         if(comportamento==null){
  3156.             this.errori.add("Non e' stato definito il comportamento di default adottato per la gestione errore ("+tipo+")");
  3157.         }else{
  3158.             if (!comportamento.equals(CostantiConfigurazione.GESTIONE_ERRORE_ACCETTA_MSG) && !comportamento.equals(CostantiConfigurazione.GESTIONE_ERRORE_RISPEDISCI_MSG))
  3159.                 this.errori.add("Il comportamento di default associato alla gestione errore ("+tipo+") deve assumere uno dei seguenti valori: "+
  3160.                         CostantiConfigurazione.GESTIONE_ERRORE_ACCETTA_MSG+" o "+CostantiConfigurazione.GESTIONE_ERRORE_RISPEDISCI_MSG);
  3161.         }
  3162.         
  3163.         // Cadenza rispedizione
  3164.         if(ge.getCadenzaRispedizione()!=null){
  3165.             try{
  3166.                 Long.parseLong(ge.getCadenzaRispedizione());
  3167.             }catch(Exception e){
  3168.                 this.errori.add("Il valore della cadenza di rispedizione di default associato alla gestione errore ("+tipo+"), dev'essere un numero intero");
  3169.             }
  3170.         }
  3171.     }







  3179.     /* ------------------ UTILITY ------------------------------*/

  3181.     /*
  3182.     private boolean existsSoggetto(String tipo,String nome){
  3183.         return this.getSoggetto(tipo, nome)!=null;
  3184.     }
  3185.     private Soggetto getSoggetto(String tipo,String nome){
  3186.         for(int j=0; j<this.configurazione.sizeSoggettoList();j++){
  3187.             Soggetto ss = this.configurazione.getSoggetto(j);
  3188.             if (tipo.equals(ss.getTipo()) && nome.equals(ss.getNome())) {
  3189.                 return ss;
  3190.             }
  3191.         }
  3192.         return null;
  3193.     }*/
  3194.     
  3195.     private boolean existsServizioApplicativo(String nome,Soggetto soggetto){
  3196.         return this.getServizioApplicativo(nome,soggetto)!=null;
  3197.     }
  3198.     private ServizioApplicativo getServizioApplicativo(String nome,Soggetto soggetto){
  3199.         for(int j=0; j<soggetto.sizeServizioApplicativoList();j++){
  3200.             ServizioApplicativo sa = soggetto.getServizioApplicativo(j);
  3201.             if (nome.equals(sa.getNome())) {
  3202.                 return sa;
  3203.             }
  3204.         }
  3205.         return null;
  3206.     }

  3208. }
Created with JaCoCo 0.8.8.202204050719