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



  23. package org.openspcoop2.protocol.spcoop.validator;

  25. import org.openspcoop2.core.id.IDServizio;
  26. import org.openspcoop2.core.id.IDSoggetto;
  27. import org.openspcoop2.core.registry.driver.DriverRegistroServiziException;
  28. import org.openspcoop2.core.registry.driver.DriverRegistroServiziNotFound;
  29. import org.openspcoop2.core.registry.driver.IDServizioFactory;
  30. import org.openspcoop2.message.OpenSPCoop2Message;
  31. import org.openspcoop2.protocol.basic.BasicStateComponentFactory;
  32. import org.openspcoop2.protocol.registry.RegistroServiziManager;
  33. import org.openspcoop2.protocol.registry.RegistroServiziReader;
  34. import org.openspcoop2.protocol.registry.RisultatoValidazione;
  35. import org.openspcoop2.protocol.sdk.Busta;
  36. import org.openspcoop2.protocol.sdk.Context;
  37. import org.openspcoop2.protocol.sdk.Eccezione;
  38. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  39. import org.openspcoop2.protocol.sdk.ProtocolException;
  40. import org.openspcoop2.protocol.sdk.Riscontro;
  41. import org.openspcoop2.protocol.sdk.SecurityInfo;
  42. import org.openspcoop2.protocol.sdk.Servizio;
  43. import org.openspcoop2.protocol.sdk.Trasmissione;
  44. import org.openspcoop2.protocol.sdk.config.ITraduttore;
  45. import org.openspcoop2.protocol.sdk.constants.CodiceErroreCooperazione;
  46. import org.openspcoop2.protocol.sdk.constants.ContestoCodificaEccezione;
  47. import org.openspcoop2.protocol.sdk.constants.Inoltro;
  48. import org.openspcoop2.protocol.sdk.constants.LivelloRilevanza;
  49. import org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione;
  50. import org.openspcoop2.protocol.sdk.constants.RuoloBusta;
  51. import org.openspcoop2.protocol.sdk.constants.TipoOraRegistrazione;
  52. import org.openspcoop2.protocol.sdk.state.IState;
  53. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  54. import org.openspcoop2.protocol.sdk.validator.IValidazioneSemantica;
  55. import org.openspcoop2.protocol.sdk.validator.ProprietaValidazione;
  56. import org.openspcoop2.protocol.sdk.validator.ValidazioneSemanticaResult;
  57. import org.openspcoop2.protocol.spcoop.constants.SPCoopCostanti;
  58. import org.openspcoop2.protocol.spcoop.constants.SPCoopCostantiPosizioneEccezione;
  59. import org.openspcoop2.utils.digest.IDigestReader;



  63. /**
  64.  * Classe che implementa, in base al protocollo SPCoop, l'interfaccia {@link org.openspcoop2.protocol.sdk.validator.IValidazioneSemantica}
  65.  *
  66.  * @author Poli Andrea (apoli@link.it)
  67.  * @author $Author$
  68.  * @version $Rev$, $Date$
  69.  */

  71. public class SPCoopValidazioneSemantica extends BasicStateComponentFactory implements IValidazioneSemantica {

  73.     /** Errori di validazione riscontrati sulla busta */
  74.     private java.util.List<Eccezione> erroriValidazione;
  75.     /** Errori di processamento riscontrati sulla busta */
  76.     private java.util.List<Eccezione> erroriProcessamento;
  77.     /** Busta */
  78.     private Busta busta;
  79.     /** Validazione IDEGov completa */
  80.     private boolean validazioneIDEGovCompleta = false;


  83.     /** ServizioCorrelato */
  84.     private String servizioCorrelato;
  85.     /** Tipo ServizioCorrelato */
  86.     private String tipoServizioCorrelato;
  87.     /** Versione ServizioCorrelato */
  88.     private Integer versioneServizioCorrelato = 1; // in spcoop รจ fissa
  89.     /** Azione Correlata */
  90.     private String azioneCorrelata;
  91.     /** Reader Registro */
  92.     private RegistroServiziManager registroServiziReader;
  93.     /** informazioni Servizio */
  94.     private Servizio infoServizio = null;
  95.     
  96.     @SuppressWarnings("unused")
  97.     private Context context;
  98.     

  100.     /**
  101.      * Costruttore.
  102.      *
  103.      * @param protocolFactory ProtocolFactory
  104.      * @throws ProtocolException 
  105.      * 
  106.      */
  107.     public SPCoopValidazioneSemantica(IProtocolFactory<?> protocolFactory,IState state) throws ProtocolException{
  108.         super(protocolFactory,state);
  109.     }

  111.     
  112.     @Override
  113.     public void setContext(Context context) {
  114.         this.context = context;
  115.     }
  116.     

  118.     /**
  119.      * Metodo che effettua la validazione dei soggetti di una busta, controllando la loro registrazione nel registro dei servizi. 
  120.      *
  121.      * Mano mano che sono incontrati errori di validazione, viene creato un oggetto 
  122.      *   {@link Eccezione}, e viene inserito nel List <var>errors</var>.
  123.      *
  124.      * @param tipoValidazione tipo di Validazione
  125.      * 
  126.      */
  127.     public void valida(ProprietaValidazione tipoValidazione, RuoloBusta tipoBusta, String profiloGestione){

  129.         try{
  130.             RequestInfo requestInfo = null;
  131.             if(this.context!=null && this.context.containsKey(org.openspcoop2.core.constants.Costanti.REQUEST_INFO)) {
  132.                 requestInfo = (RequestInfo) this.context.getObject(org.openspcoop2.core.constants.Costanti.REQUEST_INFO);
  133.             }
  134.             
  135.             this.erroriValidazione = new java.util.ArrayList<Eccezione>();
  136.             this.erroriProcessamento = new java.util.ArrayList<Eccezione>();
  137.             //log.info("Validazione semantica...");         
  138.             
  139.             /* Accesso al registro */
  140.             if( RegistroServiziReader.isInitialize()==false || this.registroServiziReader==null){
  141.                 this.log.error("Registro dei Servizi non inizializzato.");
  142.                 Eccezione ecc = new Eccezione();
  143.                 ecc.setContestoCodifica(ContestoCodificaEccezione.PROCESSAMENTO);
  144.                 ecc.setCodiceEccezione(CodiceErroreCooperazione.ERRORE_GENERICO_PROCESSAMENTO_MESSAGGIO);
  145.                 ecc.setRilevanza(LivelloRilevanza.ERROR);
  146.                 ecc.setDescrizione("Registro dei Servizi non disponibile");
  147.                 this.erroriProcessamento.add(ecc);
  148.                 return;
  149.             }
  150.             

  152.             //log.info("Validazione mittente...");
  153.             // Mittente: check registrazione nel Registro dei Servizi
  154.             IDSoggetto soggMitt = new IDSoggetto(this.busta.getTipoMittente(),this.busta.getMittente());
  155.             String dominioMittente = null;
  156.             boolean mittenteSconosciuto = false;
  157.             try{
  158.                 dominioMittente = this.registroServiziReader.getDominio(soggMitt,null,this.protocolFactory, requestInfo); //null=allRegistri 
  159.                 if(dominioMittente==null)
  160.                     throw new Exception("Dominio non definito");
  161.                 else
  162.                     this.busta.setIdentificativoPortaMittente(dominioMittente);
  163.             }catch(DriverRegistroServiziNotFound es){
  164.                 Eccezione ecc = new Eccezione();
  165.                 ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  166.                 ecc.setCodiceEccezione(CodiceErroreCooperazione.MITTENTE_SCONOSCIUTO);
  167.                 ecc.setRilevanza(LivelloRilevanza.ERROR);
  168.                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_MITTENTE_SCONOSCIUTO_POSIZIONE_IDENTIFICATIVO_PARTE.toString());
  169.                 this.log.debug("Identificazione mittente fallita:"+es.getMessage());
  170.                 this.erroriValidazione.add(ecc);
  171.                 mittenteSconosciuto = true;
  172.             }catch(Exception es){
  173.                 Eccezione ecc = new Eccezione();
  174.                 ecc.setContestoCodifica(ContestoCodificaEccezione.PROCESSAMENTO);
  175.                 ecc.setCodiceEccezione(CodiceErroreCooperazione.ERRORE_GENERICO_PROCESSAMENTO_MESSAGGIO);
  176.                 ecc.setRilevanza(LivelloRilevanza.ERROR);
  177.                 ecc.setDescrizione("Identificazione mittente non riuscita: errore di processamento");
  178.                 this.log.error("Identificazione mittente non riuscita",es);
  179.                 this.erroriProcessamento.add(ecc);
  180.                 mittenteSconosciuto = true;
  181.             }

  183.             //log.info("Validazione destinatario...");
  184.             // Destinatario: check registrazione nel Registro dei Servizi
  185.             IDSoggetto soggDest = new IDSoggetto(this.busta.getTipoDestinatario(),this.busta.getDestinatario());
  186.             String dominioDestinatario = null;
  187.             boolean destinatarioSconosciuto = false;
  188.             try{
  189.                 dominioDestinatario = this.registroServiziReader.getDominio(soggDest,null,this.protocolFactory, requestInfo); // null=allRegistri
  190.                 if(dominioDestinatario==null)
  191.                     throw new Exception("Dominio non definito");
  192.                 else
  193.                     this.busta.setIdentificativoPortaDestinatario(dominioDestinatario);
  194.             }catch(DriverRegistroServiziNotFound es){
  195.                 Eccezione ecc = new Eccezione();
  196.                 ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  197.                 ecc.setCodiceEccezione(CodiceErroreCooperazione.DESTINATARIO_SCONOSCIUTO);
  198.                 ecc.setRilevanza(LivelloRilevanza.ERROR);
  199.                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_DESTINATARIO_SCONOSCIUTO_POSIZIONE_IDENTIFICATIVO_PARTE.toString());
  200.                 this.log.debug("Identificazione destinatario fallita: "+es.getMessage());
  201.                 this.erroriValidazione.add(ecc);
  202.                 destinatarioSconosciuto = true;
  203.             }catch(Exception es){
  204.                 Eccezione ecc = new Eccezione();
  205.                 ecc.setContestoCodifica(ContestoCodificaEccezione.PROCESSAMENTO);
  206.                 ecc.setCodiceEccezione(CodiceErroreCooperazione.ERRORE_GENERICO_PROCESSAMENTO_MESSAGGIO);
  207.                 ecc.setRilevanza(LivelloRilevanza.ERROR);
  208.                 ecc.setDescrizione("Identificazione destinatario non riuscita: errore di processamento");
  209.                 this.log.error("Identificazione destinatario non riuscita",es);
  210.                 this.erroriProcessamento.add(ecc);
  211.                 destinatarioSconosciuto = true;
  212.             }

  214.             // Riconoscimento servizio-azione: viene effettuato per Richiesta/Risposta/Ricevuta
  215.             // Per risposte e ricevute, viene controllato che esista servizio e azione associate al mittente della busta
  216.             // per richieste, viene controllato che esista servizio e azione associate al destinatario della busta
  217.             RisultatoValidazione risultatoValidazioneServizio = null;
  218.             if( RuoloBusta.BUSTA_DI_SERVIZIO.equals(tipoBusta.toString()) == false ){ 
  219.                 //log.info("Validazione servizio azione...");
  220.                 risultatoValidazioneServizio = riconoscimentoServizioAzione(tipoBusta,mittenteSconosciuto,destinatarioSconosciuto);
  221.             }
  222.             // Controllo correlazione alla richiesta per buste contenenti Risposte o ricevute 
  223.             //System.out.println("TIPO BUSTA ["+tipoBusta+"]");
  224.             // LOGICA SPOSTATA NELL'ENGINE VALIDATOR
  225. //          if( RuoloBusta.BUSTA_DI_SERVIZIO.equals(tipoBusta.toString()) == false &&
  226. //                  RuoloBusta.RICHIESTA.equals(tipoBusta.toString()) == false){ 
  227. //              //log.info("Validazione correlazione...");
  228. //              validazioneCorrelazione(tipoBusta);
  229. //          }

  231.             // boolean indicazione se il servizio e' stato riconosciuto in base a mittente, destinatario servizio e azione
  232.             boolean servizioBustaValido = false;
  233.             if( (RuoloBusta.BUSTA_DI_SERVIZIO.equals(tipoBusta.toString()) == false ) &&
  234.                     (destinatarioSconosciuto==false) &&
  235.                     (mittenteSconosciuto==false) ){ 
  236.                 //this.log.info("Indicazione servizio...");
  237.                 if(risultatoValidazioneServizio!=null && risultatoValidazioneServizio.getServizioRegistrato()){
  238.                     if( (this.busta.getAzione()==null) && (risultatoValidazioneServizio.getAccessoSenzaAzione()) ){
  239.                         servizioBustaValido = true;
  240.                     }else if(this.busta.getAzione()!=null){
  241.                         if(risultatoValidazioneServizio.getAzioni()!=null){
  242.                             for(int j=0; j<risultatoValidazioneServizio.sizeAzioni();j++){
  243.                                 if(this.busta.getAzione().equals(risultatoValidazioneServizio.getAzioni()[j])){
  244.                                     servizioBustaValido = true;
  245.                                     break;
  246.                                 }
  247.                             }
  248.                         }
  249.                     }
  250.                 } 
  251.                 //this.log.info("Raccolta info servizio...");
  252.                 if(servizioBustaValido){
  253.                     IDSoggetto idSoggettoFruitore = new IDSoggetto();
  254.                     IDSoggetto idSoggettoErogatore = new IDSoggetto();
  255.                     this.impostaFruitoreErogatoreRealiServizio(idSoggettoFruitore,idSoggettoErogatore,tipoBusta);
  256.                     
  257.                     IDServizio idServizio = IDServizioFactory.getInstance().getIDServizioFromValues(this.busta.getTipoServizio(),this.busta.getServizio(), 
  258.                             idSoggettoErogatore, 
  259.                             this.busta.getVersioneServizio());
  260.                     idServizio.setAzione(this.busta.getAzione());
  261.                     try{
  262.                         this.infoServizio = this.registroServiziReader.getInfoServizio(idSoggettoFruitore,idServizio,null,false, true, requestInfo);//null=allRegistri
  263.                     }catch(DriverRegistroServiziNotFound dnot){}
  264.                     if(this.infoServizio==null){
  265.                         try{
  266.                             this.infoServizio = this.registroServiziReader.getInfoServizioCorrelato(soggMitt, idServizio, null, true, requestInfo);//null=allRegistri
  267.                         }catch(DriverRegistroServiziNotFound dnot){}
  268.                     }
  269.                     if(this.infoServizio==null){
  270.                         Eccezione ecc = new Eccezione();
  271.                         ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  272.                         ecc.setCodiceEccezione(CodiceErroreCooperazione.ERRORE_GENERICO_PROCESSAMENTO_MESSAGGIO);
  273.                         ecc.setRilevanza(LivelloRilevanza.ERROR);
  274.                         ecc.setDescrizione("Raccolta informazioni servizio: servizio sconosciuto");
  275.                         this.erroriValidazione.add(ecc);
  276.                         servizioBustaValido = false;
  277.                     }
  278.                 }
  279.                 //this.log.info("Raccolta info servizio effettuata");
  280.             }
  281.         
  282.             
  283.             
  284.             // Riconoscimento profilo di collaborazione: viene controllato che sia usato il profilo di collaborazione registrato
  285.             // Per risposte e ricevute, viene controllato che esista servizio e azione associate al mittente della busta (fruitore e' destinatario)
  286.             // per richieste, viene controllato che esista servizio e azione associate al destinatario della busta (fruitore e' destinatario)
  287.             if( (servizioBustaValido) && (tipoValidazione.isValidazioneProfiloCollaborazione()) && (RuoloBusta.RICHIESTA.equals(tipoBusta.toString())) ){
  288.                 riconoscimentoProfiloCollaborazione(tipoBusta);
  289.             }

  291.             // Identificativo Messaggio: viene controllato che l'identificativo porta sia quello del mittente della busta
  292.             //log.info("Validazione ID...");
  293.             if(mittenteSconosciuto==false){
  294.                 if( validazioneID_engine(this.busta.getID(),this.busta.getMittente(),dominioMittente) == false ){
  295.                     Eccezione ecc = new Eccezione();
  296.                     ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  297.                     ecc.setCodiceEccezione(CodiceErroreCooperazione.IDENTIFICATIVO_MESSAGGIO_NON_VALIDO);
  298.                     ecc.setRilevanza(LivelloRilevanza.ERROR);
  299.                     ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_ID_MESSAGGIO_NON_VALIDO_POSIZIONE.toString());
  300.                     this.erroriValidazione.add(ecc);
  301.                 }
  302.             }

  304.             // Riferimento Messaggio: viene controllato che l'identificativo porta sia quello del mittente della busta
  305.             //                        viene inoltro controllato che il riferimento messaggio sia quello aspettato per il profilo gestito
  306.             if(this.busta.getRiferimentoMessaggio()!=null){
  307.                 //log.info("Validazione RifMsg... ["+tipoBusta+"] ["+this.busta.getRiferimentoMessaggio()+"]");
  308.                 boolean validazioneIDRiferimentoMessaggio = true;
  309.                 if(ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO.equals(this.busta.getProfiloDiCollaborazione()) &&
  310.                         RuoloBusta.RISPOSTA.equals(tipoBusta.toString())){
  311.                     // per il profilo asincrono asimmetrico devo usare come dominio/nome per il rifMsg il mittente, invece che il destinatario
  312.                     if(mittenteSconosciuto==false){
  313.                         validazioneIDRiferimentoMessaggio = validazioneID_engine(this.busta.getRiferimentoMessaggio(),this.busta.getMittente(),dominioMittente);
  314.                     }
  315.                 }else{
  316.                     if(destinatarioSconosciuto==false){
  317.                         validazioneIDRiferimentoMessaggio = validazioneID_engine(this.busta.getRiferimentoMessaggio(),this.busta.getDestinatario(),dominioDestinatario);
  318.                     }
  319.                 }
  320.                 if(validazioneIDRiferimentoMessaggio  == false ){
  321.                     Eccezione ecc = new Eccezione();
  322.                     ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  323.                     ecc.setCodiceEccezione(CodiceErroreCooperazione.RIFERIMENTO_MESSAGGIO_NON_VALIDO);
  324.                     ecc.setRilevanza(LivelloRilevanza.ERROR);
  325.                     ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_RIFERIMENTO_MESSAGGIO_NON_VALIDO_POSIZIONE.toString());
  326.                     this.erroriValidazione.add(ecc);
  327.                 }else{
  328.                     //log.info("Validazione RifMsg specifico...");
  329.                     // LOGICA SPOSTATA NELL'ENGINE VALIDATOR
  330.                     //validazioneRiferimentoMessaggio(tipoBusta);
  331.                 }
  332.             }

  334.             // Controllo Collaborazione (validazioneID e Riconoscimento)
  335.             // Controllo che non deve essere effettuato se ho ricevuto un Fault
  336.             // LOGICA DI RICONOSCIMENTO COLLABORAZIONE SPOSTATA NELL'ENGINE VALIDATOR.
  337.             // Qua viene controllato solo la struttura dell'id
  338.             if( RuoloBusta.BUSTA_DI_SERVIZIO.equals(tipoBusta.toString()) == false ){ 
  339.                 //log.info("Validazione Collaborazione...");
  340.                 validazioneCollaborazione(tipoBusta,dominioMittente,dominioDestinatario);
  341.             }

  343.             // Validazione Sequenza: se presente, ci deve essere anche una collaborazione valida (se si arriva qua, e' garantito) 
  344.             // ed un profiloTrasmissione con 'inoltro= ALPIUUNAVOLTA' e 'conferma=TRUE'
  345.             //log.info("Validazione Sequenza...");
  346.             if( (SPCoopCostanti.PROFILO_CNIPA_LINEE_GUIDA_11_BUSTA_EGOV_11.equals(profiloGestione)==false) &&  (this.busta.getSequenza() != -1) ){
  347.                 if( (this.busta.getCollaborazione() == null) ||
  348.                         (this.busta.getInoltro() == null)  ){
  349.                     Eccezione ecc = new Eccezione();
  350.                     ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  351.                     ecc.setCodiceEccezione(CodiceErroreCooperazione.CONSEGNA_IN_ORDINE_NON_VALIDA);
  352.                     ecc.setRilevanza(LivelloRilevanza.ERROR);
  353.                     if( (this.busta.getCollaborazione() == null) && (this.busta.getInoltro() == null))
  354.                         ecc.setDescrizione("Sequenza non gestibile, elementi Collaborazione e ProfiloTrasmissione non presenti");
  355.                     else if( this.busta.getCollaborazione() == null ){
  356.                         ecc.setDescrizione("Sequenza non gestibile, elemento Collaborazione non presente");
  357.                     }else{
  358.                         ecc.setDescrizione("Sequenza non gestibile, elemento ProfiloTrasmissione non presente");
  359.                     }
  360.                     this.erroriValidazione.add(ecc);
  361.                 }else{ 
  362.                     if( (Inoltro.SENZA_DUPLICATI.equals(this.busta.getInoltro())==false)||
  363.                             (this.busta.isConfermaRicezione()==false) ){
  364.                         Eccezione ecc = new Eccezione();
  365.                         ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  366.                         ecc.setCodiceEccezione(CodiceErroreCooperazione.CONSEGNA_IN_ORDINE_NON_GESTIBILE);
  367.                         ecc.setRilevanza(LivelloRilevanza.ERROR);
  368.                         if((Inoltro.SENZA_DUPLICATI.equals(this.busta.getInoltro())==false) && (this.busta.isConfermaRicezione()==false)){
  369.                             ecc.setDescrizione("Sequenza non gestibile, attributi dell'elemento ProfiloTrasmissione non validi con la sequenza");
  370.                         }else if(this.busta.isConfermaRicezione()==false){
  371.                             ecc.setDescrizione("Sequenza non gestibile, attributo confermaRicezione dell'elemento ProfiloTrasmissione non valido con la sequenza");
  372.                         }else{
  373.                             ecc.setDescrizione("Sequenza non gestibile, attributo inoltro dell'elemento ProfiloTrasmissione non valido con la sequenza");
  374.                         }
  375.                         this.erroriValidazione.add(ecc);
  376.                     }
  377.                 }
  378.             }

  380.             // Riscontri (ID)
  381.             //log.info("Validazione Riscontri...");
  382.             for(int i=0; i<this.busta.sizeListaRiscontri();i++){
  383.                 Riscontro r = this.busta.getRiscontro(i);
  384.                 if(validazioneID_engine(r.getID()) == false){
  385.                     Eccezione ecc = new Eccezione();
  386.                     ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  387.                     ecc.setCodiceEccezione(CodiceErroreCooperazione.RISCONTRO_IDENTIFICATIVO_MESSAGGIO_NON_VALIDO);
  388.                     ecc.setRilevanza(LivelloRilevanza.ERROR);
  389.                     ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_RISCONTRI_NON_VALIDA_POSIZIONE_RISCONTRO_IDENTIFICATORE.toString());
  390.                     this.erroriValidazione.add(ecc);
  391.                 }
  392.             }

  394.             // Trasmissione (Origine e Destinazione)
  395.             //log.info("Validazione Trasmissione...");
  396.             for(int i=0; i<this.busta.sizeListaTrasmissioni();i++){
  397.                 Trasmissione t = this.busta.getTrasmissione(i);

  399.                 IDSoggetto soggOrig = new IDSoggetto(t.getTipoOrigine(),t.getOrigine());
  400.                 String dominioOrig = null;
  401.                 try{
  402.                     dominioOrig = this.registroServiziReader.getDominio(soggOrig,null,this.protocolFactory, requestInfo); // null=allRegistri
  403.                     if(dominioOrig==null)
  404.                         throw new Exception("Dominio non definito");
  405.                     else
  406.                         t.setIdentificativoPortaOrigine(dominioOrig);
  407.                 }catch(DriverRegistroServiziNotFound es){
  408.                     Eccezione ecc = new Eccezione();
  409.                     ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  410.                     ecc.setCodiceEccezione(CodiceErroreCooperazione.TRASMISSIONE_ORIGINE_NON_VALIDA);
  411.                     ecc.setRilevanza(LivelloRilevanza.ERROR);
  412.                     ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_TRASMISSIONI_NON_VALIDA_POSIZIONE_TRASMISSIONE_ORIGINE_IDENTIFICATIVO_PARTE.toString());
  413.                     this.log.debug("Identificazione origine trasmissione fallita:"+es.getMessage());
  414.                     this.erroriValidazione.add(ecc);
  415.                 }catch(Exception es){
  416.                     Eccezione ecc = new Eccezione();
  417.                     ecc.setContestoCodifica(ContestoCodificaEccezione.PROCESSAMENTO);
  418.                     ecc.setCodiceEccezione(CodiceErroreCooperazione.ERRORE_GENERICO_PROCESSAMENTO_MESSAGGIO);
  419.                     ecc.setRilevanza(LivelloRilevanza.ERROR);
  420.                     ecc.setDescrizione("Identificazione origine della trasmissione non riuscita: errore di processamento");
  421.                     this.log.error("Identificazione origine trasmissione non riuscita",es);
  422.                     this.erroriProcessamento.add(ecc);
  423.                 }

  425.                 IDSoggetto soggDestTr = new IDSoggetto(t.getTipoDestinazione(),t.getDestinazione());
  426.                 String dominioDestinatarioTr = null;
  427.                 try{
  428.                     dominioDestinatarioTr = this.registroServiziReader.getDominio(soggDestTr,null,this.protocolFactory, requestInfo); // null=allRegistri
  429.                     if(dominioDestinatarioTr==null)
  430.                         throw new Exception("Dominio non definito");
  431.                     else
  432.                         t.setIdentificativoPortaDestinazione(dominioDestinatarioTr);
  433.                 }catch(DriverRegistroServiziNotFound es){
  434.                     Eccezione ecc = new Eccezione();
  435.                     ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  436.                     ecc.setCodiceEccezione(CodiceErroreCooperazione.TRASMISSIONE_DESTINAZIONE_NON_VALIDA);
  437.                     ecc.setRilevanza(LivelloRilevanza.ERROR);
  438.                     ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_TRASMISSIONI_NON_VALIDA_POSIZIONE_TRASMISSIONE_DESTINAZIONE_IDENTIFICATIVO_PARTE.toString());
  439.                     this.log.debug("Identificazione destinazione trasmissione fallita:"+es.getMessage());
  440.                     this.erroriValidazione.add(ecc);
  441.                 }catch(Exception es){
  442.                     Eccezione ecc = new Eccezione();
  443.                     ecc.setContestoCodifica(ContestoCodificaEccezione.PROCESSAMENTO);
  444.                     ecc.setCodiceEccezione(CodiceErroreCooperazione.ERRORE_GENERICO_PROCESSAMENTO_MESSAGGIO);
  445.                     ecc.setRilevanza(LivelloRilevanza.ERROR);
  446.                     ecc.setDescrizione("Identificazione destinazione della trasmissione non riuscita: errore di processamento");
  447.                     this.log.error("Identificazione destinazione trasmissione non riuscita",es);
  448.                     this.erroriProcessamento.add(ecc);
  449.                 }
  450.             }

  452.             
  453.             // Validazione LineeGuida1.1
  454.             if(SPCoopCostanti.PROFILO_CNIPA_LINEE_GUIDA_11_BUSTA_EGOV_11.equals(profiloGestione)){
  455.                 // log.info("Validazione LineeGuida1.1...");
  456.                 this.validazioneLineeGuida11();
  457.             }

  459.         } catch(Exception e) {
  460.             this.log.error("ValidazioneSemantica: riscontrato errore durante la validazione",e);
  461.             Eccezione ecc = new Eccezione();
  462.             ecc.setContestoCodifica(ContestoCodificaEccezione.PROCESSAMENTO);
  463.             ecc.setCodiceEccezione(CodiceErroreCooperazione.ERRORE_GENERICO_PROCESSAMENTO_MESSAGGIO);
  464.             ecc.setRilevanza(LivelloRilevanza.ERROR);
  465.             ecc.setDescrizione("Errore di processamento durante la validazione semantica.");
  466.             this.erroriProcessamento.add(ecc);
  467.         }

  469.     }


  472.     

  474.     private void validazioneCollaborazione(RuoloBusta tipoBusta,String dominioMittente,String dominioDestinatario) throws ProtocolException{
  475.         
  476.         // La collaborazione deve appartenere o al mittente, o al destinatario della busta.
  477.         if(this.busta.getCollaborazione()!=null){
  478.             if( (validazioneID_engine(this.busta.getCollaborazione(),this.busta.getMittente(),dominioMittente) == false) &&
  479.                     (validazioneID_engine(this.busta.getCollaborazione(),this.busta.getDestinatario(),dominioDestinatario) == false) ){
  480.                 Eccezione ecc = new Eccezione();
  481.                 ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  482.                 ecc.setCodiceEccezione(CodiceErroreCooperazione.COLLABORAZIONE_SCONOSCIUTA);
  483.                 ecc.setRilevanza(LivelloRilevanza.ERROR);
  484.                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_COLLABORAZIONE_SCONOSCIUTA_POSIZIONE.toString());
  485.                 this.erroriValidazione.add(ecc);
  486.                 return;
  487.             }
  488.         }
  489.     
  490.     }
  491.     
  492.  
  493.     private void impostaFruitoreErogatoreRealiServizio(IDSoggetto fruitore,IDSoggetto erogatore,RuoloBusta tipoBusta){
  494.         if( (RuoloBusta.RICHIESTA.equals(tipoBusta.toString())) || 
  495.                     ((RuoloBusta.RISPOSTA.equals(tipoBusta.toString())) && (ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO.equals(this.busta.getProfiloDiCollaborazione()))) ||
  496.                     ((RuoloBusta.RISPOSTA.equals(tipoBusta.toString())) && (ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO.equals(this.busta.getProfiloDiCollaborazione()))) ){ 
  497.             if(erogatore!=null){    
  498.                 erogatore.setTipo(this.busta.getTipoDestinatario());
  499.                 erogatore.setNome(this.busta.getDestinatario());
  500.             }
  501.             if(fruitore!=null){
  502.                 fruitore.setTipo(this.busta.getTipoMittente());
  503.                 fruitore.setNome(this.busta.getMittente());
  504.             }
  505.         }else if((RuoloBusta.RISPOSTA.equals(tipoBusta.toString())) || (RuoloBusta.RICEVUTA_RICHIESTA.equals(tipoBusta.toString())) || (RuoloBusta.RICEVUTA_RISPOSTA.equals(tipoBusta.toString()))){
  506.             if(erogatore!=null){    
  507.                 erogatore.setTipo(this.busta.getTipoMittente());
  508.                 erogatore.setNome(this.busta.getMittente());
  509.             }
  510.             if(fruitore!=null){
  511.                 fruitore.setTipo(this.busta.getTipoDestinatario());
  512.                 fruitore.setNome(this.busta.getDestinatario());
  513.             }
  514.         }
  515.         

  517.     }
  518.     
  519.     /**
  520.      * Metodo che si occupa di validare l'elemento 'Servizio' e 'Azione', controllando 
  521.      * che siano riconosciuti all'interno del registro dei servizi di riferimento (es. registro UDDI)
  522.      *
  523.      * @param tipoBusta tipo di Busta da validare
  524.      * 
  525.      */
  526.     private RisultatoValidazione riconoscimentoServizioAzione(RuoloBusta tipoBusta,boolean mittenteSconosciuto,boolean destinatarioSconosciuto) throws ProtocolException,DriverRegistroServiziException{

  528.         if(mittenteSconosciuto)
  529.             return null;
  530.         if(destinatarioSconosciuto)
  531.             return null;
  532.         IDSoggetto idSoggettoErogatore = new IDSoggetto();
  533.         IDSoggetto idSoggettoFruitore = null;
  534.         // Per richiesta asincrono simmetrico serve anche il fruitore per la localizzazione del servizio correlato
  535.         if( (ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO.equals(this.busta.getProfiloDiCollaborazione())) &&
  536.                     (RuoloBusta.RICHIESTA.equals(tipoBusta.toString())) ){
  537.             idSoggettoFruitore = new IDSoggetto();
  538.         }else if( (ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO.equals(this.busta.getProfiloDiCollaborazione())) ){
  539.             idSoggettoFruitore = new IDSoggetto();
  540.         }
  541.         this.impostaFruitoreErogatoreRealiServizio(idSoggettoFruitore,idSoggettoErogatore,tipoBusta);
  542.         

  544.         // 1) Validazione Servizio
  545.         RisultatoValidazione validazione = null;
  546.         if(this.busta.getServizio()!=null && this.busta.getTipoServizio()!=null){
  547.             IDServizio idService = IDServizioFactory.getInstance().getIDServizioFromValues(this.busta.getTipoServizio(),this.busta.getServizio(), 
  548.                     idSoggettoErogatore, 
  549.                     this.busta.getVersioneServizio());
  550.             idService.setAzione(this.busta.getAzione());
  551.             try{
  552.                 validazione = this.registroServiziReader.validaServizio(idSoggettoFruitore,idService,null); //null=allRegistri  
  553.             }catch(Exception e){
  554.                 this.log.error("Errore durante l'accesso al registro per la validazione del servizio e dell'azione",e);
  555.                 Eccezione ecc = new Eccezione();
  556.                 ecc.setContestoCodifica(ContestoCodificaEccezione.PROCESSAMENTO);
  557.                 ecc.setCodiceEccezione(CodiceErroreCooperazione.ERRORE_GENERICO_PROCESSAMENTO_MESSAGGIO);
  558.                 ecc.setRilevanza(LivelloRilevanza.ERROR);
  559.                 ecc.setDescrizione("Riconoscimento Servizio/Azione: errore di processamento");
  560.                 this.erroriProcessamento.add(ecc);
  561.                 return null;
  562.             }
  563.             if(validazione.getServizioRegistrato()==false){
  564.                 Eccezione ecc = new Eccezione();
  565.                 ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  566.                 ecc.setCodiceEccezione(CodiceErroreCooperazione.SERVIZIO_SCONOSCIUTO);
  567.                 ecc.setRilevanza(LivelloRilevanza.ERROR);
  568.                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_SERVIZIO_SCONOSCIUTO_POSIZIONE.toString());
  569.                 this.erroriValidazione.add(ecc);
  570.                 return validazione;
  571.             }
  572.             this.servizioCorrelato = validazione.getServizioCorrelato();
  573.             this.tipoServizioCorrelato = validazione.getTipoServizioCorrelato();
  574.             this.versioneServizioCorrelato = validazione.getVersioneServizioCorrelato();
  575.             this.azioneCorrelata = validazione.getAzioneCorrelata();
  576.         }



  580.         // 2) Validazione Azione (solo se c'e' un servizio)
  581.         if(this.busta.getServizio()!=null && this.busta.getTipoServizio()!=null){
  582.             
  583.             if(validazione==null) {
  584.                 this.log.error("Errore durante l'accesso al registro per la validazione del servizio e dell'azione: validazione is null");
  585.                 Eccezione ecc = new Eccezione();
  586.                 ecc.setContestoCodifica(ContestoCodificaEccezione.PROCESSAMENTO);
  587.                 ecc.setCodiceEccezione(CodiceErroreCooperazione.ERRORE_GENERICO_PROCESSAMENTO_MESSAGGIO);
  588.                 ecc.setRilevanza(LivelloRilevanza.ERROR);
  589.                 ecc.setDescrizione("Riconoscimento Azione: errore di processamento");
  590.                 this.erroriProcessamento.add(ecc);
  591.                 return null;
  592.             }
  593.             
  594.             //log.info("Validazione Azione...");
  595.             if(this.busta.getAzione() == null){
  596.                 // Controllo che sia valida una invocazione senza azione
  597.                 if(validazione.getAccessoSenzaAzione() == false){
  598.                     Eccezione ecc = new Eccezione();
  599.                     ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  600.                     ecc.setCodiceEccezione(CodiceErroreCooperazione.INVOCAZIONE_SENZA_AZIONE_NON_PERMESSA);
  601.                     ecc.setRilevanza(LivelloRilevanza.ERROR);
  602.                     ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_AZIONE_SCONOSCIUTA_POSIZIONE.toString());
  603.                     this.erroriValidazione.add(ecc);
  604.                     return validazione;
  605.                 }
  606.             }else{
  607.                 String[]azioni = validazione.getAzioni();
  608.                 boolean azioneTrovata = false;
  609.                 if(azioni!=null){
  610.                     for(int i=0;i<azioni.length;i++){
  611.                         if(this.busta.getAzione().equals(azioni[i])){
  612.                             azioneTrovata=true;
  613.                             break;
  614.                         }
  615.                     }
  616.                 }
  617.                 if(azioneTrovata==false){
  618.                     Eccezione ecc = new Eccezione();
  619.                     ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  620.                     ecc.setCodiceEccezione(CodiceErroreCooperazione.AZIONE_SCONOSCIUTA);
  621.                     ecc.setRilevanza(LivelloRilevanza.ERROR);
  622.                     ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_AZIONE_SCONOSCIUTA_POSIZIONE.toString());
  623.                     this.erroriValidazione.add(ecc);
  624.                     return validazione;
  625.                 }
  626.             }
  627.         }

  629.         
  630.         // 3) Validazione elementi ServizioCorrelato e TipoServizioCorrelato
  631.         if(ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO.equals(this.busta.getProfiloDiCollaborazione()) 
  632.                 && RuoloBusta.RICHIESTA.equals(tipoBusta.toString())){
  633.             /* Con la certificazione CNIPA, questi attributi non sono piu' obbligatori */
  634.             /*if( (this.busta.getServizioCorrelato()==null) || (this.busta.getTipoServizioCorrelato()==null) ||
  635.                     (this.busta.getTipoServizioCorrelato().equals(validazione.getTipoServizioCorrelato())== false) ||
  636.                     (this.busta.getServizioCorrelato().equals(validazione.getServizioCorrelato())== false) ){
  637.                 Eccezione ecc = new Eccezione();
  638.                 ecc.setContestoCodifica(Costanti.CONTESTO_CODIFICA_ECCEZIONE_VALIDAZIONE);
  639.                 ecc.setCodiceEccezione(Costanti.ECCEZIONE_SERVIZIO_SCONOSCIUTO);
  640.                 ecc.setRilevanza(Costanti.GRAVE);
  641.                 ecc.setDescrizione("Servizio Correlato non valido (o non presente) nella richiesta asincrona simmetrica");
  642.                 this.erroriValidazione.add(ecc);
  643.                 return;
  644.             }*/
  645.             // NEW ALGORITM:
  646.             if( 
  647.                     (this.busta.getServizioCorrelato()!=null) && 
  648.                     validazione!=null &&
  649.                     (this.busta.getServizioCorrelato().equals(validazione.getServizioCorrelato())== false)
  650.             ){
  651.                 Eccezione ecc = new Eccezione();
  652.                 ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  653.                 ecc.setCodiceEccezione(CodiceErroreCooperazione.SERVIZIO_CORRELATO_NON_VALIDO);
  654.                 ecc.setRilevanza(LivelloRilevanza.ERROR);
  655.                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_PROFILO_COLLABORAZIONE_SCONOSCIUTO_POSIZIONE_SERVIZIO_CORRELATO+" diverso da quello atteso (richiesta asincrona simmetrica)");
  656.                 this.erroriValidazione.add(ecc);
  657.                 return validazione;
  658.             }
  659.             if( 
  660.                     (this.busta.getTipoServizioCorrelato()!=null) && 
  661.                     validazione!=null &&
  662.                     (this.busta.getTipoServizioCorrelato().equals(validazione.getTipoServizioCorrelato())== false)
  663.             ){
  664.                 Eccezione ecc = new Eccezione();
  665.                 ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  666.                 ecc.setCodiceEccezione(CodiceErroreCooperazione.TIPO_SERVIZIO_CORRELATO_NON_VALIDO);
  667.                 ecc.setRilevanza(LivelloRilevanza.ERROR);
  668.                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_PROFILO_COLLABORAZIONE_SCONOSCIUTO_POSIZIONE_TIPO_SERVIZIO_CORRELATO+" diverso da quello atteso (richiesta asincrona simmetrica)");
  669.                 this.erroriValidazione.add(ecc);
  670.                 return validazione;
  671.             }

  673.         }
  674.         if(ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO.equals(this.busta.getProfiloDiCollaborazione()) 
  675.                 && RuoloBusta.RICEVUTA_RICHIESTA.equals(tipoBusta.toString())  ){
  676.             /* Con la certificazione CNIPA, questi attributi non sono piu' obbligatori */
  677.             /*
  678.             if( (this.busta.getServizioCorrelato()==null) || (this.busta.getTipoServizioCorrelato()==null) ||
  679.                     (this.busta.getTipoServizioCorrelato().equals(validazione.getTipoServizioCorrelato())== false) ||
  680.                     (this.busta.getServizioCorrelato().equals(validazione.getServizioCorrelato())== false) ){
  681.                 Eccezione ecc = new Eccezione();
  682.                 ecc.setContestoCodifica(Costanti.CONTESTO_CODIFICA_ECCEZIONE_VALIDAZIONE);
  683.                 ecc.setCodiceEccezione(Costanti.ECCEZIONE_SERVIZIO_SCONOSCIUTO);
  684.                 ecc.setRilevanza(Costanti.GRAVE);
  685.                 ecc.setDescrizione("Servizio Correlato non valido (o non presente) nella ricevuta della richiesta asincrona asimmetrica");
  686.                 this.erroriValidazione.add(ecc);
  687.                 return;
  688.             }*/
  689.             // NEW ALGORITM:
  690.             if( 
  691.                     (this.busta.getServizioCorrelato()!=null) && 
  692.                     validazione!=null &&
  693.                     (this.busta.getServizioCorrelato().equals(validazione.getServizioCorrelato())== false)
  694.             ){
  695.                 Eccezione ecc = new Eccezione();
  696.                 ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  697.                 ecc.setCodiceEccezione(CodiceErroreCooperazione.SERVIZIO_CORRELATO_NON_VALIDO);
  698.                 ecc.setRilevanza(LivelloRilevanza.ERROR);
  699.                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_PROFILO_COLLABORAZIONE_SCONOSCIUTO_POSIZIONE_SERVIZIO_CORRELATO+" diverso da quello atteso (ricevuta della richiesta asincrona simmetrica)");
  700.                 this.erroriValidazione.add(ecc);
  701.                 return validazione;
  702.             }
  703.             if( 
  704.                     (this.busta.getTipoServizioCorrelato()!=null) && 
  705.                     validazione!=null &&
  706.                     (this.busta.getTipoServizioCorrelato().equals(validazione.getTipoServizioCorrelato())== false)
  707.             ){
  708.                 Eccezione ecc = new Eccezione();
  709.                 ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  710.                 ecc.setCodiceEccezione(CodiceErroreCooperazione.TIPO_SERVIZIO_CORRELATO_NON_VALIDO);
  711.                 ecc.setRilevanza(LivelloRilevanza.ERROR);
  712.                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_PROFILO_COLLABORAZIONE_SCONOSCIUTO_POSIZIONE_TIPO_SERVIZIO_CORRELATO+" diverso da quello atteso (ricevuta della richiesta asincrona simmetrica)");
  713.                 this.erroriValidazione.add(ecc);
  714.                 return validazione;
  715.             }
  716.         }

  718.         
  719.         return validazione;
  720.     }
  721.     
  722.     


  725.     /**
  726.      * Metodo che si occupa di validare l'elemento 'Servizio' e 'Azione', controllando 
  727.      * che siano riconosciuti all'interno del registro dei servizi di riferimento (es. registro UDDI)
  728.      *
  729.      * @param tipoBusta tipo di Busta da validare
  730.      * 
  731.      */
  732.     private void riconoscimentoProfiloCollaborazione(RuoloBusta tipoBusta){

  734.         // Viene effettuato solo per la richiesta.
  735.         try{
  736.             if(this.infoServizio.getProfiloDiCollaborazione().equals(this.busta.getProfiloDiCollaborazione())==false){
  737.                     Eccezione ecc = new Eccezione();
  738.                     ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  739.                     ecc.setCodiceEccezione(CodiceErroreCooperazione.PROFILO_COLLABORAZIONE_NON_VALIDO);
  740.                     ecc.setRilevanza(LivelloRilevanza.ERROR);
  741.                     ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_PROFILO_COLLABORAZIONE_SCONOSCIUTO_POSIZIONE+" diverso da quanto specificato nel registro");
  742.                     this.erroriValidazione.add(ecc);
  743.             }
  744.         }catch(Exception e){
  745.             this.log.error("Errore durante l'accesso al registro per la validazione del profilo di collaborazione",e);
  746.             Eccezione ecc = new Eccezione();
  747.             ecc.setContestoCodifica(ContestoCodificaEccezione.PROCESSAMENTO);
  748.             ecc.setCodiceEccezione(CodiceErroreCooperazione.ERRORE_GENERICO_PROCESSAMENTO_MESSAGGIO);
  749.             ecc.setRilevanza(LivelloRilevanza.ERROR);
  750.             ecc.setDescrizione("Riconoscimento Profilo di Collaborazione: errore di processamento");
  751.             this.erroriProcessamento.add(ecc);
  752.         }

  754.     }

  756.     
  757.     /**
  758.      * Metodo che si occupa di validare l'identificativo <var>id</var> secondo la specifica eGov.
  759.      *
  760.      * @param id identificativo eGov da validare
  761.      * @return il valore boolean true se l'identificativo fornito e' conforme alla specifica eGov. Altrimenti false.
  762.      * 
  763.      */
  764.     public boolean validazioneID_engine(String id){
  765.         return validazioneID_engine(id,null,null);
  766.     }

  768.     /**
  769.      * Metodo che si occupa di validare l'identificativo <var>id</var> secondo la specifica eGov.
  770.      * L'identificativo e' formato da :
  771.      * codAmministrazione_codPortaDominio_num.progressivo_data_ora
  772.      * <p>
  773.      * Il codice Amministrazione e' preso da <var>codAmm</var>. 
  774.      * Il codice Amministrazione deve contenere l'identificativo parte del mittente, quando deve essere validato
  775.      * un identificativo del messaggio od una collaborazione di una richiesta 
  776.      * (oneWay, richiestaSincrona , richiesta/ricevutaRisposta AsincronaSimmetrica , 
  777.      *  richiesta/richiestaStato AsincronaAsimmetrica), poiche' e' lui che lo ha spedito 
  778.      * e che ha quindi creato l'identificatore.
  779.      * Deve contenere invece il codice del destinatario, quando deve essere validato un RiferimentoMessaggio, od una
  780.      * collaborazione di una risposta (Sincrona , ricevutaRichiesta/Risposta AsincronaSimmetrica ,
  781.      * ricevutaRichiesta/ricevutaRichiestaStato AsincronaAsimmetrica),
  782.      * poiche' la creazione dell'identificatore venne fatta dal destinatario quando creo' la richiesta.
  783.      * <p>
  784.      * Il codice amministrativo <var>codAmm</var>,  sara' utilizzato anche per ottenere dal 
  785.      * registro dei servizi di openspcoop la validazione del codice della Porta di Dominio presente nell'identificativo.
  786.      * 
  787.      *
  788.      * @param id identificativo eGov da validare
  789.      * @param codAmm Identificativo Parte mittente o destinatario di una busta.
  790.      * @param codDominio Identificativo del dominio del codice di amministrazione
  791.      * @return il valore boolean true se l'identificativo fornito e' conforme alla specifica eGov. Altrimenti false.
  792.      * 
  793.      */
  794.     public boolean validazioneID_engine(String id, String codAmm, String codDominio){

  796.         try{

  798.             // Ottengo parti dell'identificatore
  799.             String [] split = id.split("_");
  800.             if(split == null)
  801.                 return false;
  802.             if(split.length != 5)
  803.                 return false;

  805.             if(codAmm!=null && this.validazioneIDEGovCompleta){
  806.                 // Check codice amministrazione
  807.                 if(!split[0].equals(codAmm))
  808.                     return false;
  809.                 byte [] checkID = split[0].getBytes();
  810.                 for(int j=0;j<checkID.length;j++){
  811.                     if( !Character.isLetterOrDigit((char)checkID[j]))
  812.                         return false;
  813.                 } 
  814.             }

  816.             if(codDominio!=null && this.validazioneIDEGovCompleta){
  817.                 // Check codice porta di dominio        
  818.                 if(!split[1].equalsIgnoreCase(codDominio))
  819.                     return false;
  820.                 byte [] checkPDD = split[1].getBytes();
  821.                 for(int j=0;j<checkPDD.length;j++){
  822.                     if( !Character.isLetterOrDigit((char)checkPDD[j]))
  823.                         return false;
  824.                 } 

  826.             } 

  828.             // Check num progressivo
  829.             if(split[2].length() != 7)
  830.                 return false;
  831.             try{
  832.                 Integer test = Integer.valueOf(split[2]);
  833.                 if(test.intValue()<0) {
  834.                     // ignore
  835.                 }
  836.             } catch(Exception e){
  837.                 return false;
  838.             } 

  840.             // Check data yyyy-MM-dd
  841.             String [] date = split[3].split("-");
  842.             if(date == null)
  843.                 return false;
  844.             if(date.length != 3)
  845.                 return false;
  846.             if(date[0].length() != 4)
  847.                 return false;
  848.             try{
  849.                 Integer test = Integer.valueOf(date[0]);
  850.                 if(test.intValue()>2100)
  851.                     return false;
  852.             } catch(Exception e){
  853.                 return false;
  854.             } 
  855.             if(date[1].length() != 2)
  856.                 return false;
  857.             if(date[2].length() != 2)
  858.                 return false;
  859.             try{
  860.                 Integer mese = Integer.valueOf(date[1]);
  861.                 if(mese.intValue()>12 || mese.intValue() < 0)
  862.                     return false;
  863.                 Integer giorno = Integer.valueOf(date[2]);
  864.                 if(giorno.intValue() < 0)
  865.                     return false;
  866.                 if(giorno.intValue()>29 && mese.intValue() == 2)
  867.                     return false;
  868.                 else if(giorno.intValue()>30 && 
  869.                         (  (mese.intValue() == 4) ||
  870.                                 (mese.intValue() == 6) ||
  871.                                 (mese.intValue() == 9) ||
  872.                                 (mese.intValue() == 11) ) )
  873.                     return false;
  874.                 else if(giorno.intValue()>31)
  875.                     return false;
  876.             } catch(Exception e){
  877.                 return false;
  878.             } 


  881.             // Check ora hh:mm
  882.             String [] ora = split[4].split(":");
  883.             if(ora == null)
  884.                 return false;
  885.             if(ora.length != 2)
  886.                 return false;
  887.             if(ora[0].length() != 2)
  888.                 return false;
  889.             try{
  890.                 Integer test = Integer.valueOf(ora[0]);
  891.                 if(test.intValue() > 23 || test.intValue() < 0)
  892.                     return false;
  893.             } catch(Exception e){
  894.                 return false;
  895.             } 
  896.             if(ora[1].length() != 2)
  897.                 return false;
  898.             try{
  899.                 Integer test = Integer.valueOf(ora[1]);
  900.                 if(test.intValue() > 59 || test.intValue() < 0)
  901.                     return false;
  902.             } catch(Exception e){
  903.                 return false;
  904.             } 

  906.             return true;

  908.         }catch(Exception error){
  909.             return false;
  910.         }
  911.     }

  913.     private void validazioneLineeGuida11() throws ProtocolException{
  914.         
  915.         ITraduttore traduttore = this.protocolFactory.createTraduttore();
  916.         String valoreEngine = traduttore.toRegistryOrganizationType(SPCoopCostanti.SERVIZIO_SPC);
  917.         
  918.         //    mittente
  919.         if(valoreEngine.equals(this.busta.getTipoMittente())==false){
  920.             Eccezione ecc = new Eccezione();
  921.             ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  922.             ecc.setCodiceEccezione(CodiceErroreCooperazione.TIPO_MITTENTE_NON_VALIDO);
  923.             ecc.setRilevanza(LivelloRilevanza.ERROR);
  924.             ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_MITTENTE_SCONOSCIUTO_POSIZIONE_IDENTIFICATIVO_PARTE_TIPO.toString());
  925.             this.erroriValidazione.add(ecc);
  926.         }
  927.         
  928.         //    destinatario
  929.         if(valoreEngine.equals(this.busta.getTipoDestinatario())==false){
  930.             Eccezione ecc = new Eccezione();
  931.             ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  932.             ecc.setCodiceEccezione(CodiceErroreCooperazione.TIPO_DESTINATARIO_NON_VALIDO);
  933.             ecc.setRilevanza(LivelloRilevanza.ERROR);
  934.             ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_DESTINATARIO_SCONOSCIUTO_POSIZIONE_IDENTIFICATIVO_PARTE_TIPO.toString());
  935.             this.erroriValidazione.add(ecc);
  936.         }
  937.         
  938.         // Servizio e' obbligatorio in questo profilo (queste sono eccezioni GRAVI!)
  939.         if(this.busta.getTipoServizio()==null){
  940.             Eccezione ecc = new Eccezione();
  941.             ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  942.             ecc.setCodiceEccezione(CodiceErroreCooperazione.TIPO_SERVIZIO_NON_PRESENTE);
  943.             ecc.setRilevanza(LivelloRilevanza.ERROR);
  944.             ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_SERVIZIO_SCONOSCIUTO_POSIZIONE_TIPO.toString());
  945.             this.erroriValidazione.add(ecc);
  946.         }
  947.         if(this.busta.getServizio()==null){
  948.             Eccezione ecc = new Eccezione();
  949.             ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  950.             ecc.setCodiceEccezione(CodiceErroreCooperazione.SERVIZIO_NON_PRESENTE);
  951.             ecc.setRilevanza(LivelloRilevanza.ERROR);
  952.             ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_SERVIZIO_SCONOSCIUTO_POSIZIONE.toString());
  953.             this.erroriValidazione.add(ecc);
  954.         }
  955.         
  956.         //        servizio
  957.         if(valoreEngine.equals(this.busta.getTipoServizio())==false){
  958.             Eccezione ecc = new Eccezione();
  959.             ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  960.             ecc.setCodiceEccezione(CodiceErroreCooperazione.TIPO_SERVIZIO_NON_VALIDO);
  961.             ecc.setRilevanza(LivelloRilevanza.ERROR);
  962.             ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_SERVIZIO_SCONOSCIUTO_POSIZIONE_TIPO.toString());
  963.             this.erroriValidazione.add(ecc);
  964.         }
  965.         
  966.         // Azione e' obbligatoria (queste sono eccezioni GRAVI!)
  967.         if(this.busta.getAzione()==null){
  968.             Eccezione ecc = new Eccezione();
  969.             ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  970.             ecc.setCodiceEccezione(CodiceErroreCooperazione.AZIONE_NON_PRESENTE);
  971.             ecc.setRilevanza(LivelloRilevanza.ERROR);
  972.             ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_AZIONE_SCONOSCIUTA_POSIZIONE.toString());
  973.             this.erroriValidazione.add(ecc);
  974.         }
  975.         
  976.         // Profilo di Collaborazione
  977.         if(this.busta.getProfiloDiCollaborazione()==null){
  978.             Eccezione ecc = new Eccezione();
  979.             ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  980.             ecc.setCodiceEccezione(CodiceErroreCooperazione.PROFILO_COLLABORAZIONE_NON_PRESENTE);
  981.             ecc.setRilevanza(LivelloRilevanza.ERROR);
  982.             ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_PROFILO_COLLABORAZIONE_SCONOSCIUTO_POSIZIONE.toString());
  983.             this.erroriValidazione.add(ecc);
  984.         }

  986.         // Collaborazione (valida solo per profili asincroni)
  987.         if(  ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO.equals(this.busta.getProfiloDiCollaborazione()) 
  988.                 ||
  989.              ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO.equals(this.busta.getProfiloDiCollaborazione()) ){
  990.             if(this.busta.getCollaborazione()==null){
  991.                 Eccezione ecc = new Eccezione();
  992.                 ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  993.                 ecc.setCodiceEccezione(CodiceErroreCooperazione.COLLABORAZIONE_NON_VALIDA);
  994.                 ecc.setRilevanza(LivelloRilevanza.ERROR);
  995.                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_COLLABORAZIONE_SCONOSCIUTA_POSIZIONE.toString());
  996.                 this.erroriValidazione.add(ecc);
  997.             }
  998.         } 
  999.         
  1000.         // OraRegistrazione
  1001.         if(TipoOraRegistrazione.SINCRONIZZATO.equals(this.busta.getTipoOraRegistrazione())==false){
  1002.             Eccezione ecc = new Eccezione();
  1003.             ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  1004.             ecc.setCodiceEccezione(CodiceErroreCooperazione.TIPO_ORA_REGISTRAZIONE_NON_VALIDA);
  1005.             ecc.setRilevanza(LivelloRilevanza.ERROR);
  1006.             ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_ORA_REGISTRAZIONE_NON_VALIDA_POSIZIONE_TEMPO.toString());
  1007.             this.erroriValidazione.add(ecc);
  1008.         }
  1009.         
  1010.         // Profilo di Trasmissione (queste sono eccezioni GRAVI!)
  1011.         if(this.busta.isConfermaRicezione()==true){
  1012.             Eccezione ecc = new Eccezione();
  1013.             ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  1014.             ecc.setCodiceEccezione(CodiceErroreCooperazione.PROFILO_TRASMISSIONE_CONFERMA_RICEZIONE_NON_VALIDO);
  1015.             ecc.setRilevanza(LivelloRilevanza.ERROR);
  1016.             ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_PROFILO_TRASMISSIONE_NON_VALIDO_POSIZIONE_CONFERMA_RICEZIONE.toString());
  1017.             this.erroriValidazione.add(ecc);
  1018.         }
  1019.         if(Inoltro.CON_DUPLICATI.equals(this.busta.getInoltro())){
  1020.             Eccezione ecc = new Eccezione();
  1021.             ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  1022.             ecc.setCodiceEccezione(CodiceErroreCooperazione.PROFILO_TRASMISSIONE_FILTRO_DUPLICATI_NON_VALIDO);
  1023.             ecc.setRilevanza(LivelloRilevanza.ERROR);
  1024.             ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_PROFILO_TRASMISSIONE_NON_VALIDO_POSIZIONE_INOLTRO.toString());
  1025.             this.erroriValidazione.add(ecc);
  1026.         }
  1027.                 
  1028.         for(int i=0; i<this.busta.sizeListaTrasmissioni(); i++){
  1029.             Trasmissione tr = this.busta.getTrasmissione(i);
  1030.             if(valoreEngine.equals(tr.getTipoOrigine())==false){
  1031.                 Eccezione ecc = new Eccezione();
  1032.                 ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  1033.                 ecc.setCodiceEccezione(CodiceErroreCooperazione.TRASMISSIONE_TIPO_ORIGINE_NON_VALIDA);
  1034.                 ecc.setRilevanza(LivelloRilevanza.ERROR);
  1035.                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_TRASMISSIONI_NON_VALIDA_POSIZIONE_TRASMISSIONE_ORIGINE_IDENTIFICATIVO_PARTE_TIPO.toString());
  1036.                 this.erroriValidazione.add(ecc);
  1037.             }
  1038.             if(valoreEngine.equals(tr.getTipoDestinazione())==false){
  1039.                 Eccezione ecc = new Eccezione();
  1040.                 ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  1041.                 ecc.setCodiceEccezione(CodiceErroreCooperazione.TRASMISSIONE_TIPO_DESTINAZIONE_NON_VALIDA);
  1042.                 ecc.setRilevanza(LivelloRilevanza.ERROR);
  1043.                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_TRASMISSIONI_NON_VALIDA_POSIZIONE_TRASMISSIONE_DESTINAZIONE_IDENTIFICATIVO_PARTE_TIPO.toString());
  1044.                 this.erroriValidazione.add(ecc);
  1045.             }
  1046.             if(TipoOraRegistrazione.SINCRONIZZATO.equals(tr.getTempo())==false){
  1047.                 Eccezione ecc = new Eccezione();
  1048.                 ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  1049.                 ecc.setCodiceEccezione(CodiceErroreCooperazione.TRASMISSIONE_TIPO_ORA_REGISTRAZIONE_NON_VALIDA);
  1050.                 ecc.setRilevanza(LivelloRilevanza.ERROR);
  1051.                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_TRASMISSIONI_NON_VALIDA_POSIZIONE_TRASMISSIONE_ORA_REGISTRAZIONE_TEMPO.toString());
  1052.                 this.erroriValidazione.add(ecc);
  1053.             }
  1054.         }
  1055.         
  1056.         // Lista riscontri
  1057.         for(int i=0; i<this.busta.sizeListaRiscontri(); i++){
  1058.             Riscontro r = this.busta.getRiscontro(i);
  1059.             if(TipoOraRegistrazione.SINCRONIZZATO.equals(r.getTipoOraRegistrazione())==false){
  1060.                 Eccezione ecc = new Eccezione();
  1061.                 ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  1062.                 ecc.setCodiceEccezione(CodiceErroreCooperazione.RISCONTRO_TIPO_ORA_REGISTRAZIONE_NON_VALIDO);
  1063.                 ecc.setRilevanza(LivelloRilevanza.ERROR);
  1064.                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_RISCONTRI_NON_VALIDA_POSIZIONE_RISCONTRO_ORA_REGISTRAZIONE_TEMPO.toString());
  1065.                 this.erroriValidazione.add(ecc);
  1066.             }
  1067.         }
  1068.         
  1069.         
  1070.         
  1071.         
  1072.         // Segnalo errori di tipo INFO SOLO SE non ci sono stati gia errori di tipo GRAVE
  1073.         if(this.erroriValidazione.size()==0){
  1074.             
  1075.             // Indirizzo telematico mittente
  1076.             if(this.busta.getIndirizzoMittente()!=null){
  1077.                 Eccezione ecc = new Eccezione();
  1078.                 ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  1079.                 ecc.setCodiceEccezione(CodiceErroreCooperazione.INDIRIZZO_MITTENTE_NON_VALIDO);
  1080.                 ecc.setRilevanza(LivelloRilevanza.INFO);
  1081.                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_MITTENTE_SCONOSCIUTO_POSIZIONE_IDENTIFICATIVO_PARTE_IND_TELEMATICO.toString());
  1082.                 this.erroriValidazione.add(ecc);
  1083.             }
  1084.             
  1085.             // Indirizzo telematico destinatario
  1086.             if(this.busta.getIndirizzoDestinatario()!=null){
  1087.                 Eccezione ecc = new Eccezione();
  1088.                 ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  1089.                 ecc.setCodiceEccezione(CodiceErroreCooperazione.INDIRIZZO_DESTINATARIO_NON_VALIDO);
  1090.                 ecc.setRilevanza(LivelloRilevanza.INFO);
  1091.                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_DESTINATARIO_SCONOSCIUTO_POSIZIONE_IDENTIFICATIVO_PARTE_IND_TELEMATICO.toString());
  1092.                 this.erroriValidazione.add(ecc);
  1093.             }
  1094.             
  1095.             // Profilo di Collaborazione
  1096.             if(this.busta.getTipoServizioCorrelato()!=null){
  1097.                 Eccezione ecc = new Eccezione();
  1098.                 ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  1099.                 ecc.setCodiceEccezione(CodiceErroreCooperazione.TIPO_SERVIZIO_CORRELATO_NON_VALIDO);
  1100.                 ecc.setRilevanza(LivelloRilevanza.INFO);
  1101.                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_PROFILO_COLLABORAZIONE_SCONOSCIUTO_POSIZIONE_TIPO_SERVIZIO_CORRELATO.toString());
  1102.                 this.erroriValidazione.add(ecc);
  1103.             }
  1104.             if(this.busta.getServizioCorrelato()!=null){
  1105.                 Eccezione ecc = new Eccezione();
  1106.                 ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  1107.                 ecc.setCodiceEccezione(CodiceErroreCooperazione.SERVIZIO_CORRELATO_NON_VALIDO);
  1108.                 ecc.setRilevanza(LivelloRilevanza.INFO);
  1109.                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_PROFILO_COLLABORAZIONE_SCONOSCIUTO_POSIZIONE_SERVIZIO_CORRELATO.toString());
  1110.                 this.erroriValidazione.add(ecc);
  1111.             }
  1112.             
  1113.             // Collaborazione valida solo per gli asincroni
  1114.             if(  (ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO.equals(this.busta.getProfiloDiCollaborazione())==false)  
  1115.                     &&
  1116.                  (ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO.equals(this.busta.getProfiloDiCollaborazione())==false) ){
  1117.                 if(this.busta.getCollaborazione()!=null){
  1118.                     Eccezione ecc = new Eccezione();
  1119.                     ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  1120.                     ecc.setCodiceEccezione(CodiceErroreCooperazione.COLLABORAZIONE_NON_VALIDA);
  1121.                     ecc.setRilevanza(LivelloRilevanza.INFO);
  1122.                     ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_COLLABORAZIONE_SCONOSCIUTA_POSIZIONE.toString());
  1123.                     this.erroriValidazione.add(ecc);
  1124.                 }
  1125.             }
  1126.             
  1127.             // Sequenza
  1128.             if(this.busta.getSequenza()!=-1){
  1129.                 Eccezione ecc = new Eccezione();
  1130.                 ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  1131.                 ecc.setCodiceEccezione(CodiceErroreCooperazione.CONSEGNA_IN_ORDINE_NON_SUPPORTATA);
  1132.                 ecc.setRilevanza(LivelloRilevanza.INFO);
  1133.                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_TRASPARENZA_TEMPORALE_NON_SUPPORTATA_POSIZIONE.toString());
  1134.                 this.erroriValidazione.add(ecc);
  1135.             }
  1136.             
  1137.             // Lista trasmissioni
  1138.             /* L'hanno riammessa.
  1139.             if(this.busta.sizeListaTrasmissioni()>0){
  1140.                 Eccezione ecc = new Eccezione();
  1141.                 ecc.setContestoCodifica(Costanti.CONTESTO_CODIFICA_ECCEZIONE_VALIDAZIONE);
  1142.                 ecc.setCodiceEccezione(Costanti.ECCEZIONE_FORMATO_INTESTAZIONE_NON_CORRETTO);
  1143.                 ecc.setRilevanza(LivelloRilevanza.INFO);
  1144.                 ecc.setDescrizione(Costanti.ECCEZIONE_LISTA_TRASMISSIONI_NON_VALIDA_POSIZIONE);
  1145.                 this.erroriValidazione.add(ecc);
  1146.             }*/
  1147.             for(int i=0; i<this.busta.sizeListaTrasmissioni(); i++){
  1148.                 Trasmissione tr = this.busta.getTrasmissione(i);
  1149.                 if(tr.getIndirizzoOrigine()!=null){
  1150.                     Eccezione ecc = new Eccezione();
  1151.                     ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  1152.                     ecc.setCodiceEccezione(CodiceErroreCooperazione.TRASMISSIONE_INDIRIZZO_ORIGINE_NON_VALIDA);
  1153.                     ecc.setRilevanza(LivelloRilevanza.INFO);
  1154.                     ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_TRASMISSIONI_NON_VALIDA_POSIZIONE_TRASMISSIONE_ORIGINE_IDENTIFICATIVO_PARTE_IND_TELEMATICO.toString());
  1155.                     this.erroriValidazione.add(ecc);
  1156.                 }
  1157.                 if(tr.getIndirizzoDestinazione()!=null){
  1158.                     Eccezione ecc = new Eccezione();
  1159.                     ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  1160.                     ecc.setCodiceEccezione(CodiceErroreCooperazione.TRASMISSIONE_INDIRIZZO_DESTINAZIONE_NON_VALIDA);
  1161.                     ecc.setRilevanza(LivelloRilevanza.INFO);
  1162.                     ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_TRASMISSIONI_NON_VALIDA_POSIZIONE_TRASMISSIONE_DESTINAZIONE_IDENTIFICATIVO_PARTE_IND_TELEMATICO.toString());
  1163.                     this.erroriValidazione.add(ecc);
  1164.                 }
  1165.             }
  1166.             
  1167.             // Lista riscontri
  1168.             if(this.busta.sizeListaRiscontri()>0){
  1169.                 Eccezione ecc = new Eccezione();
  1170.                 ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  1171.                 ecc.setCodiceEccezione(CodiceErroreCooperazione.LISTA_RISCONTRI_NON_VALIDA);
  1172.                 ecc.setRilevanza(LivelloRilevanza.INFO);
  1173.                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_RISCONTRI_NON_VALIDA_POSIZIONE.toString());
  1174.                 this.erroriValidazione.add(ecc);
  1175.             }
  1176.         }
  1177.     }
  1178.     

  1180.     public String getAzioneCorrelata() {
  1181.         return this.azioneCorrelata;
  1182.     }
  1183.     public void setAzioneCorrelata(String azioneCorrelata) {
  1184.         this.azioneCorrelata = azioneCorrelata;
  1185.     }


  1188.     @Override
  1189.     public IProtocolFactory<?> getProtocolFactory() {
  1190.         return this.protocolFactory;
  1191.     }


  1194.     @Override
  1195.     public boolean validazioneID(String id, IDSoggetto dominio, ProprietaValidazione proprietaValidazione) {
  1196.         this.validazioneIDEGovCompleta = proprietaValidazione.isValidazioneIDCompleta();
  1197.         if(dominio!=null){
  1198.             return this.validazioneID_engine(id, dominio.getNome(), dominio.getCodicePorta());
  1199.         }else{
  1200.             return this.validazioneID_engine(id, null, null);
  1201.         }
  1202.     }


  1205.     @Override
  1206.     public ValidazioneSemanticaResult valida(OpenSPCoop2Message msg, Busta busta, 
  1207.             ProprietaValidazione proprietaValidazione, RuoloBusta tipoBusta)
  1208.             throws ProtocolException {
  1209.         this.busta = busta;
  1210.         this.registroServiziReader = RegistroServiziManager.getInstance(this.state);
  1211.         this.validazioneIDEGovCompleta = proprietaValidazione.isValidazioneIDCompleta();
  1212.         this.valida(proprietaValidazione, tipoBusta, proprietaValidazione.getVersioneProtocollo());
  1213.         ValidazioneSemanticaResult result = new ValidazioneSemanticaResult(this.erroriValidazione, this.erroriProcessamento, 
  1214.                 this.servizioCorrelato, this.tipoServizioCorrelato, this.versioneServizioCorrelato, this.infoServizio);
  1215.         return result;
  1216.     }

  1218.     
  1219.     @Override
  1220.     public SecurityInfo readSecurityInformation(IDigestReader digestReader, OpenSPCoop2Message msg) throws ProtocolException{
  1221.         return null;
  1222.     }
  1223. }
Created with JaCoCo 0.8.8.202204050719