SPCoopValidazioneSintattica.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;


  26. import java.net.URL;
  27. import java.text.SimpleDateFormat;
  28. import java.util.Date;
  29. import java.util.GregorianCalendar;
  30. import java.util.List;

  32. import javax.xml.soap.AttachmentPart;
  33. import javax.xml.soap.Detail;
  34. import javax.xml.soap.Name;
  35. import javax.xml.soap.SOAPBody;
  36. import javax.xml.soap.SOAPFault;
  37. import javax.xml.soap.SOAPHeader;
  38. import javax.xml.soap.SOAPHeaderElement;

  40. import org.openspcoop2.core.constants.TipoPdD;
  41. import org.openspcoop2.core.id.IDSoggetto;
  42. import org.openspcoop2.message.OpenSPCoop2Message;
  43. import org.openspcoop2.message.OpenSPCoop2MessageFactory;
  44. import org.openspcoop2.message.OpenSPCoop2SoapMessage;
  45. import org.openspcoop2.message.constants.Costanti;
  46. import org.openspcoop2.message.constants.MessageRole;
  47. import org.openspcoop2.message.constants.MessageType;
  48. import org.openspcoop2.message.soap.SoapUtils;
  49. import org.openspcoop2.protocol.basic.BasicStateComponentFactory;
  50. import org.openspcoop2.protocol.sdk.Busta;
  51. import org.openspcoop2.protocol.sdk.Context;
  52. import org.openspcoop2.protocol.sdk.Eccezione;
  53. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  54. import org.openspcoop2.protocol.sdk.ProtocolException;
  55. import org.openspcoop2.protocol.sdk.Riscontro;
  56. import org.openspcoop2.protocol.sdk.Trasmissione;
  57. import org.openspcoop2.protocol.sdk.builder.ProprietaManifestAttachments;
  58. import org.openspcoop2.protocol.sdk.config.ITraduttore;
  59. import org.openspcoop2.protocol.sdk.constants.CodiceErroreCooperazione;
  60. import org.openspcoop2.protocol.sdk.constants.ContestoCodificaEccezione;
  61. import org.openspcoop2.protocol.sdk.constants.CostantiProtocollo;
  62. import org.openspcoop2.protocol.sdk.constants.ErroreCooperazione;
  63. import org.openspcoop2.protocol.sdk.constants.Inoltro;
  64. import org.openspcoop2.protocol.sdk.constants.LivelloRilevanza;
  65. import org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione;
  66. import org.openspcoop2.protocol.sdk.constants.RuoloMessaggio;
  67. import org.openspcoop2.protocol.sdk.constants.TipoOraRegistrazione;
  68. import org.openspcoop2.protocol.sdk.state.IState;
  69. import org.openspcoop2.protocol.sdk.validator.IValidazioneSintattica;
  70. import org.openspcoop2.protocol.sdk.validator.ProprietaValidazioneErrori;
  71. import org.openspcoop2.protocol.sdk.validator.StrutturaBustaException;
  72. import org.openspcoop2.protocol.sdk.validator.ValidazioneSintatticaResult;
  73. import org.openspcoop2.protocol.spcoop.SPCoopBustaRawContent;
  74. import org.openspcoop2.protocol.spcoop.config.SPCoopProperties;
  75. import org.openspcoop2.protocol.spcoop.constants.SPCoopCostanti;
  76. import org.openspcoop2.protocol.spcoop.constants.SPCoopCostantiPosizioneEccezione;
  77. import org.openspcoop2.protocol.spcoop.utils.SPCoopUtils;
  78. import org.openspcoop2.utils.date.DateManager;
  79. import org.openspcoop2.utils.date.DateUtils;
  80. import org.w3c.dom.Node;

  82. /**
  83.  * Classe che implementa, in base al protocollo SPCoop, l'interfaccia {@link org.openspcoop2.protocol.sdk.validator.IValidazioneSintattica}
  84.  *
  85.  * @author Poli Andrea (apoli@link.it)
  86.  * @author Lorenzo Nardi (nardi@link.it)
  87.  * @author $Author$
  88.  * @version $Rev$, $Date$
  89.  */
  90. public class SPCoopValidazioneSintattica extends BasicStateComponentFactory implements IValidazioneSintattica<SOAPHeaderElement>{

  92.     /** Messaggio. */
  93.     private OpenSPCoop2SoapMessage msg;
  94.     public void setMsg(OpenSPCoop2SoapMessage msg) {
  95.         this.msg = msg;
  96.     }
  97.     /** HeaderSOAP */
  98.     private SOAPHeader headerSOAP = null;
  99.     /** Header SPCoop */
  100.     private SPCoopBustaRawContent headerEGov;
  101.     public void setHeaderSOAP(SOAPHeader headerSOAP) {
  102.         this.headerSOAP = headerSOAP;
  103.     }
  104.     /** Errori di validazione riscontrati sulla busta */
  105.     private java.util.List<Eccezione> erroriValidazione;
  106.     /** Errori di processamento riscontrati sulla busta */
  107.     private java.util.List<Eccezione> erroriProcessamento;
  108.     /** Errors riscontrati sulla lista eccezioni */
  109.     private java.util.List<Eccezione> errorsTrovatiSullaListaEccezioni;
  110.     /** Busta */
  111.     private Busta busta;
  112.     /** Eventuale messaggio di errore avvenuto durante il processo di validazione */
  113.     private String msgErrore;
  114.     /** Eventuale codice di errore avvenuto durante il processo di validazione  */
  115.     private CodiceErroreCooperazione codiceErrore;
  116.     /** Indicazione se leggere gli attributi qualificati */
  117.     private boolean readQualifiedAttribute;
  118.     public void setReadQualifiedAttribute(boolean readQualifiedAttribute) {
  119.         this.readQualifiedAttribute = readQualifiedAttribute;
  120.     }

  122.     private boolean segnalazioneElementoPresentePiuVolte = false;
  123.     
  124.     /** Indicazione se la busta risulta scaduta */
  125.     private boolean messaggioScaduto = false;
  126.     
  127.     /** bustaErroreHeaderIntestazione: generata solo quando la busta egov arrivata non contiene gli elementi principali */
  128.     private Busta bustaErroreHeaderIntestazione = null;
  129.     
  130. //  private List<String> tipiSoggetti = null;
  131. //  private List<String> tipiServizi = null;

  133.     private ITraduttore traduttore = null;
  134.     
  135.     private SPCoopProperties spcoopProperties = null;
  136.     
  137.     @SuppressWarnings("unused")
  138.     private Context context;
  139.     
  140.     /**
  141.      * Costruttore
  142.      *
  143.      * @param protocolFactory ProtocolFactory
  144.      * @throws ProtocolException 
  145.      * 
  146.      */
  147.     public SPCoopValidazioneSintattica(IProtocolFactory<SOAPHeaderElement> protocolFactory,IState state) throws ProtocolException{
  148.         super(protocolFactory,state);
  149.         this.errorsTrovatiSullaListaEccezioni = new java.util.ArrayList<Eccezione>();
  150.         this.erroriProcessamento = new java.util.ArrayList<Eccezione>();
  151.         this.erroriValidazione = new java.util.ArrayList<Eccezione>();
  152.         
  153. //      this.tipiSoggetti = this.protocolFactory.createProtocolConfiguration().getTipiSoggetti();
  154. //      this.tipiServizi = this.protocolFactory.createProtocolConfiguration().getTipiServizi(ServiceBinding.SOAP);
  155.         
  156.         this.traduttore = this.protocolFactory.createTraduttore();
  157.         
  158.         this.spcoopProperties = SPCoopProperties.getInstance(this.log);
  159.     }


  162.     public SPCoopBustaRawContent getHeaderEGov(OpenSPCoop2SoapMessage aMsg, boolean readQualifiedAttribute) throws ProtocolException{
  163.         this.msg = aMsg;
  164.         this.readQualifiedAttribute = readQualifiedAttribute;
  165.         return getHeaderEGov();
  166.     }
  167.     /**
  168.      * Ritorna l'header SPCoop.
  169.      *
  170.      * @return header SPCoop.
  171.      * 
  172.      */
  173.     public SPCoopBustaRawContent getHeaderEGov() throws ProtocolException{
  174.         try{
  175.             if(this.headerEGov!=null){
  176.                 return this.headerEGov;
  177.             }else{
  178.                 if(this.headerSOAP==null){
  179.                     this.headerSOAP = this.msg.getSOAPHeader();
  180.                 }
  181.                 this.headerEGov = this.getHeaderEGov(this.msg.getFactory(), this.headerSOAP);
  182.                 return this.headerEGov;
  183.             }
  184.         }catch(Exception e){
  185.             this.log.error("ValidazioneSintattica.headerEGovAsBytes error: "+e.getMessage(),e);
  186.             throw new ProtocolException("ValidazioneSintattica.headerEGovAsBytes error: "+e.getMessage(),e);
  187.         }
  188.     }


  191.     @Override
  192.     public void setContext(Context context) {
  193.         this.context = context;
  194.     }

  196.     /**
  197.      * Oggetto Busta SPCoop contenente i valori della busta ricevuta.
  198.      *
  199.      * @return busta SPCoop.
  200.      * 
  201.      */
  202.     public Busta getBusta(){
  203.         return this.busta;
  204.     }

  206.     /**
  207.      * Ritorna un List contenente eventuali eccezioni di validazione riscontrate nella busta SPCoop.   
  208.      *
  209.      * @return Eccezioni riscontrate nella busta SPCoop.
  210.      * 
  211.      */
  212.     public java.util.List<Eccezione> getEccezioniValidazione(){
  213.         return this.erroriValidazione;
  214.     }
  215.     /**
  216.      * Ritorna un List contenente eventuali eccezioni di processamento riscontrate nella busta SPCoop.   
  217.      *
  218.      * @return Eccezioni riscontrate nella busta SPCoop.
  219.      * 
  220.      */
  221.     public java.util.List<Eccezione> getEccezioniProcessamento(){
  222.         return this.erroriProcessamento;
  223.     }

  225.     /**
  226.      * Ritorna un List contenente eventuali eccezioni riscontrate nella busta SPCoop durante il processo di validazione.   
  227.      *
  228.      * @return Eccezioni riscontrate nella busta SPCoop.
  229.      * 
  230.      */
  231.     public java.util.List<Eccezione> getErroriTrovatiSullaListaEccezioni(){
  232.         return this.errorsTrovatiSullaListaEccezioni;
  233.     }

  235.     /**
  236.      * In caso di avvenuto errore durante il processo di validazione, 
  237.      * questo metodo ritorna il motivo dell'errore.
  238.      *
  239.      * @return motivo dell'errore (se avvenuto).
  240.      * 
  241.      */
  242.     public String getMsgErrore(){
  243.         return this.msgErrore;
  244.     }

  246.     /**
  247.      * In caso di avvenuto errore, questo metodo ritorna il codice dell'errore.
  248.      *
  249.      * @return codice dell'errore (se avvenuto).
  250.      * 
  251.      */
  252.     public CodiceErroreCooperazione getCodiceErrore(){
  253.         return this.codiceErrore;
  254.     }

  256.     /**
  257.      * Ritorna l'header SPCoop.
  258.      *
  259.      * @return header SPCoop.
  260.      * 
  261.      */
  262.     public SPCoopBustaRawContent getHeaderSPCoop(){
  263.         return this.headerEGov;
  264.     }

  266.     /**
  267.      * Metodo che effettua una validazione sintattica di una busta SPCoop. 
  268.      * Il metodo, oltre ad effettuare la validazione della busta, si occupa anche di leggerne il contenuto e 
  269.      * di impostarlo all'interno dell'oggetto <var>busta</var>.
  270.      * Mano mano che sono incontrati errori di validazione, viene creato un oggetto 
  271.      *   {@link Eccezione}, e viene inserito nel List <var>errors</var>.
  272.      *
  273.      * @return return true in caso di validazione sintattica riuscita (con o senza anomalie), false in caso di errori di processamento.
  274.      * 
  275.      */
  276.     public boolean valida(boolean localizzaSolamenteDatiIdentificativiMinimi){

  278.         OpenSPCoop2MessageFactory messageFactory = null;
  279.         try{

  281.             /** ------ CONTROLLO PRESENZA BUSTA SPCOOP ----- */

  283.             // Estraggo header
  284.             if(this.headerSOAP==null)
  285.                 this.headerSOAP = this.msg.getSOAPHeader();
  286.             if(this.headerSOAP==null){
  287.                 this.msgErrore =  "Analizzato un messaggio senza header";
  288.                 this.codiceErrore = CodiceErroreCooperazione.FORMATO_INTESTAZIONE_NON_CORRETTO;
  289.                 return false;
  290.             }
  291.             
  292.             messageFactory = this.msg.getFactory();
  293.             
  294.             // Estraggo busta SPCoop
  295.             if(this.headerEGov==null)
  296.                 this.headerEGov = getHeaderEGov(messageFactory, this.headerSOAP);
  297.             if(this.headerEGov==null){
  298.                 this.msgErrore =  "Analizzato un messaggio senza busta SPCoop";
  299.                 this.codiceErrore = CodiceErroreCooperazione.FORMATO_INTESTAZIONE_NON_CORRETTO;
  300.                 return false;
  301.             }       
  302.             
  303.         } catch(StrutturaBustaException e) {
  304.             this.log.error("Struttura della busta non corretta: "+e.getMessage(),e);
  305.             this.msgErrore =  e.getMessage();
  306.             this.codiceErrore = CodiceErroreCooperazione.FORMATO_INTESTAZIONE_NON_CORRETTO;
  307.             return false; 
  308.         } catch(Exception e) {
  309.             this.msgErrore = "(Validazione sintattica) "+e.getMessage();
  310.             this.codiceErrore = CodiceErroreCooperazione.FORMATO_INTESTAZIONE_NON_CORRETTO;
  311.             this.busta = null;
  312.             return false;
  313.         }


  316.         try{

  318.             /** ------ VALIDAZIONE SINTATTICA -- */

  320.             // Busta da ritornare
  321.             Busta aBusta = new Busta(this.protocolFactory.getProtocol());
  322.             this.busta = aBusta;
  323.             this.erroriValidazione = new java.util.ArrayList<Eccezione>();
  324.             this.erroriProcessamento = new java.util.ArrayList<Eccezione>();
  325.             this.errorsTrovatiSullaListaEccezioni = new java.util.ArrayList<Eccezione>();

  327.             // Prefix eGov
  328.             String xmlns = getPrefix();

  330.             // Controllo Actor
  331.             //log.info("Controllo attributo Actor["+this.header.getActor()+"] ...");
  332.             if(SPCoopCostanti.ACTOR_EGOV.equals(this.headerEGov.getElement().getActor()) == false){
  333.                 if(this.spcoopProperties.isGenerazioneBustaErrore_actorScorretto()==false){
  334.                     throw new StrutturaBustaException("Header egov con actor scorretto","Actor");
  335.                 }else{
  336.                     Eccezione ecc = new Eccezione();
  337.                     ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  338.                     ecc.setCodiceEccezione(CodiceErroreCooperazione.FORMATO_INTESTAZIONE_NON_CORRETTO);
  339.                     ecc.setRilevanza(LivelloRilevanza.ERROR);
  340.                     ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_FORMATO_INTESTAZIONE_NON_CORRETTO_POSIZIONE_ACTOR.toString());
  341.                     this.erroriValidazione.add(ecc);
  342.                 }
  343.             }
  344.             
  345.             // Controllo MustUnderstand
  346.             //log.info("Controllo attributo MustUnderstand["+this.header.getMustUnderstand()+"] ...");
  347.             if(this.headerEGov.getElement().getMustUnderstand() == false){ 
  348.                 Eccezione ecc = new Eccezione();
  349.                 ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  350.                 ecc.setCodiceEccezione(CodiceErroreCooperazione.FORMATO_INTESTAZIONE_NON_CORRETTO);
  351.                 ecc.setRilevanza(LivelloRilevanza.ERROR);
  352.                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_FORMATO_INTESTAZIONE_NON_CORRETTO_POSIZIONE_MUST_UNDERSTAND.toString());
  353.                 this.erroriValidazione.add(ecc);
  354.             }
  355.             List<Node> list = SoapUtils.getNotEmptyChildNodes(messageFactory, this.headerEGov.getElement());

  357.             //  Controllo value prefix
  358.             if(SPCoopCostanti.NAMESPACE_EGOV.equals(this.headerEGov.getElement().getNamespaceURI())==false){
  359.                 Eccezione ecc = new Eccezione();
  360.                 ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  361.                 ecc.setCodiceEccezione(CodiceErroreCooperazione.FORMATO_INTESTAZIONE_NON_CORRETTO);
  362.                 ecc.setRilevanza(LivelloRilevanza.ERROR);
  363.                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_FORMATO_INTESTAZIONE_NON_CORRETTO_POSIZIONE_NAMESPACE.toString());
  364.                 this.erroriValidazione.add(ecc);
  365.             }

  367.             // intestazione messaggio
  368.             Node intestazioneMsg = list.get(0);
  369.             List<Node> headerMsg = SoapUtils.getNotEmptyChildNodes(messageFactory, intestazioneMsg);
  370.             boolean mittenteGiaTrovato = false;
  371.             boolean destinatarioGiaTrovato = false;
  372.             boolean profiloCollaborazioneGiaTrovato = false;
  373.             boolean collaborazioneGiaTrovato = false;
  374.             boolean servizioGiaTrovato = false;
  375.             boolean azioneGiaTrovato = false;
  376.             boolean messaggioGiaTrovato = false;
  377.             boolean profiloTrasmissioneGiaTrovato = false;
  378.             boolean sequenzaGiaTrovato = false;
  379.             for(int i =0; i<headerMsg.size();i++){
  380.                 Node child = headerMsg.get(i);
  381.                 //if((child.getNodeName().equals(xmlns+"Mittente"))){
  382.                 if(SoapUtils.matchLocalName(messageFactory, child, "Mittente", xmlns, SPCoopCostanti.NAMESPACE_EGOV)){
  383.                     if(mittenteGiaTrovato==false){
  384.                         validazioneMittente(messageFactory, child,xmlns);
  385.                         mittenteGiaTrovato = true;
  386.                     }else{
  387.                         if(this.spcoopProperties.isGenerazioneBustaErrore_strutturaMalformataHeaderProtocollo()==false){
  388.                             throw new StrutturaBustaException("Header egov con più di un elemento Mittente","Mittente");
  389.                         }else{
  390.                             Eccezione ecc = new Eccezione();
  391.                             ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  392.                             ecc.setCodiceEccezione(CodiceErroreCooperazione.MITTENTE_PRESENTE_PIU_VOLTE);
  393.                             ecc.setRilevanza(LivelloRilevanza.ERROR);
  394.                             if(this.segnalazioneElementoPresentePiuVolte)
  395.                                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_MITTENTE_SCONOSCIUTO_POSIZIONE+" "+CostantiProtocollo.ECCEZIONE_ELEMENTO_PRESENTE_PIU_VOLTE);
  396.                             else
  397.                                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_MITTENTE_SCONOSCIUTO_POSIZIONE.toString());
  398.                             this.erroriValidazione.add(ecc);
  399.                         }
  400.                     }
  401.                 }
  402.                 //else if((child.getNodeName().equals(xmlns+"Destinatario"))){
  403.                 else if(SoapUtils.matchLocalName(messageFactory, child, "Destinatario", xmlns, SPCoopCostanti.NAMESPACE_EGOV)){
  404.                     if(destinatarioGiaTrovato==false){
  405.                         validazioneDestinatario(messageFactory, child,xmlns);
  406.                         destinatarioGiaTrovato = true;
  407.                     }else{
  408.                         if(this.spcoopProperties.isGenerazioneBustaErrore_strutturaMalformataHeaderProtocollo()==false){
  409.                             throw new StrutturaBustaException("Header egov con più di un elemento Destinatario","Destinatario");
  410.                         }else{
  411.                             Eccezione ecc = new Eccezione();
  412.                             ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  413.                             ecc.setCodiceEccezione(CodiceErroreCooperazione.DESTINATARIO_PRESENTE_PIU_VOLTE);
  414.                             ecc.setRilevanza(LivelloRilevanza.ERROR);
  415.                             if(this.segnalazioneElementoPresentePiuVolte)
  416.                                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_DESTINATARIO_SCONOSCIUTO_POSIZIONE+" "+CostantiProtocollo.ECCEZIONE_ELEMENTO_PRESENTE_PIU_VOLTE);
  417.                             else
  418.                                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_DESTINATARIO_SCONOSCIUTO_POSIZIONE.toString());
  419.                             this.erroriValidazione.add(ecc);
  420.                         }
  421.                     }
  422.                 }
  423.                 //else if((child.getNodeName().equals(xmlns+"ProfiloCollaborazione"))){
  424.                 else if(SoapUtils.matchLocalName(messageFactory, child, "ProfiloCollaborazione", xmlns, SPCoopCostanti.NAMESPACE_EGOV)){
  425.                     // Serve per poter riconoscere il caso del profilo asincrono in modo da non localizzare una porta applicativa
  426.                     //if(localizzaSolamenteDatiIdentificativiMinimi==false){
  427.                     if(profiloCollaborazioneGiaTrovato==false){
  428.                         validazioneProfiloCollaborazione(messageFactory, child,xmlns);
  429.                         profiloCollaborazioneGiaTrovato = true;
  430.                     }else{
  431.                         if(this.spcoopProperties.isGenerazioneBustaErrore_strutturaMalformataHeaderProtocollo()==false){
  432.                             throw new StrutturaBustaException("Header egov con più di un elemento ProfiloCollaborazione","ProfiloCollaborazione");
  433.                         }else{
  434.                             Eccezione ecc = new Eccezione();
  435.                             ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  436.                             ecc.setCodiceEccezione(CodiceErroreCooperazione.PROFILO_COLLABORAZIONE_PRESENTE_PIU_VOLTE);
  437.                             ecc.setRilevanza(LivelloRilevanza.ERROR);
  438.                             if(this.segnalazioneElementoPresentePiuVolte)
  439.                                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_PROFILO_COLLABORAZIONE_SCONOSCIUTO_POSIZIONE+" "+CostantiProtocollo.ECCEZIONE_ELEMENTO_PRESENTE_PIU_VOLTE);
  440.                             else
  441.                                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_PROFILO_COLLABORAZIONE_SCONOSCIUTO_POSIZIONE.toString());
  442.                             this.erroriValidazione.add(ecc);
  443.                         }
  444.                     }
  445.                 }
  446.                 //else if((child.getNodeName().equals(xmlns+"Collaborazione"))){
  447.                 else if(SoapUtils.matchLocalName(messageFactory, child, "Collaborazione", xmlns, SPCoopCostanti.NAMESPACE_EGOV)){
  448.                     if(localizzaSolamenteDatiIdentificativiMinimi==false){
  449.                         if(collaborazioneGiaTrovato==false){
  450.                             validazioneCollaborazione(messageFactory, child);
  451.                             collaborazioneGiaTrovato = true;
  452.                         }else{
  453.                             if(this.spcoopProperties.isGenerazioneBustaErrore_strutturaMalformataHeaderProtocollo()==false){
  454.                                 throw new StrutturaBustaException("Header egov con più di un elemento Collaborazione","Collaborazione");
  455.                             }else{
  456.                                 Eccezione ecc = new Eccezione();
  457.                                 ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  458.                                 ecc.setCodiceEccezione(CodiceErroreCooperazione.COLLABORAZIONE_PRESENTE_PIU_VOLTE);
  459.                                 ecc.setRilevanza(LivelloRilevanza.ERROR);
  460.                                 if(this.segnalazioneElementoPresentePiuVolte)
  461.                                     ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_COLLABORAZIONE_SCONOSCIUTA_POSIZIONE+" "+CostantiProtocollo.ECCEZIONE_ELEMENTO_PRESENTE_PIU_VOLTE);
  462.                                 else
  463.                                     ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_COLLABORAZIONE_SCONOSCIUTA_POSIZIONE.toString());
  464.                                 this.erroriValidazione.add(ecc);
  465.                             }
  466.                         }
  467.                     }
  468.                 }
  469.                 //else if((child.getNodeName().equals(xmlns+"Servizio"))){
  470.                 else if(SoapUtils.matchLocalName(messageFactory, child, "Servizio", xmlns, SPCoopCostanti.NAMESPACE_EGOV)){
  471.                     if(servizioGiaTrovato==false){
  472.                         validazioneServizio(messageFactory, child,xmlns);
  473.                         servizioGiaTrovato = true;
  474.                     }else{
  475.                         if(this.spcoopProperties.isGenerazioneBustaErrore_strutturaMalformataHeaderProtocollo()==false){
  476.                             throw new StrutturaBustaException("Header egov con più di un elemento Servizio","Servizio");
  477.                         }else{
  478.                             Eccezione ecc = new Eccezione();
  479.                             ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  480.                             ecc.setCodiceEccezione(CodiceErroreCooperazione.SERVIZIO_PRESENTE_PIU_VOLTE);
  481.                             ecc.setRilevanza(LivelloRilevanza.ERROR);
  482.                             if(this.segnalazioneElementoPresentePiuVolte)
  483.                                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_SERVIZIO_SCONOSCIUTO_POSIZIONE+" "+CostantiProtocollo.ECCEZIONE_ELEMENTO_PRESENTE_PIU_VOLTE);
  484.                             else
  485.                                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_SERVIZIO_SCONOSCIUTO_POSIZIONE.toString());
  486.                             this.erroriValidazione.add(ecc);
  487.                         }
  488.                     }
  489.                 }
  490.                 //else if((child.getNodeName().equals(xmlns+"Azione"))){
  491.                 else if(SoapUtils.matchLocalName(messageFactory, child, "Azione", xmlns, SPCoopCostanti.NAMESPACE_EGOV)){
  492.                     if(azioneGiaTrovato==false){
  493.                         validazioneAzione(messageFactory, child);
  494.                         azioneGiaTrovato = true;
  495.                     }else{
  496.                         if(this.spcoopProperties.isGenerazioneBustaErrore_strutturaMalformataHeaderProtocollo()==false){
  497.                             throw new StrutturaBustaException("Header egov con più di un elemento Azione","Azione");
  498.                         }else{
  499.                             Eccezione ecc = new Eccezione();
  500.                             ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  501.                             ecc.setCodiceEccezione(CodiceErroreCooperazione.AZIONE_PRESENTE_PIU_VOLTE);
  502.                             ecc.setRilevanza(LivelloRilevanza.ERROR);
  503.                             if(this.segnalazioneElementoPresentePiuVolte)
  504.                                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_AZIONE_SCONOSCIUTA_POSIZIONE+" "+CostantiProtocollo.ECCEZIONE_ELEMENTO_PRESENTE_PIU_VOLTE);
  505.                             else
  506.                                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_AZIONE_SCONOSCIUTA_POSIZIONE.toString());
  507.                             this.erroriValidazione.add(ecc);
  508.                         }
  509.                     }
  510.                 }
  511.                 //else if((child.getNodeName().equals(xmlns+"Messaggio"))){
  512.                 else if(SoapUtils.matchLocalName(messageFactory, child, "Messaggio", xmlns, SPCoopCostanti.NAMESPACE_EGOV)){
  513.                     // Serve per poter riconoscere il caso del profilo asincrono in modo da non localizzare una porta applicativa
  514.                     //if(localizzaSolamenteDatiIdentificativiMinimi==false){
  515.                     if(messaggioGiaTrovato==false){
  516.                         validazioneMessaggio(messageFactory, child,xmlns);
  517.                         messaggioGiaTrovato = true;
  518.                     }else{
  519.                         if(this.spcoopProperties.isGenerazioneBustaErrore_strutturaMalformataHeaderProtocollo()==false){
  520.                             throw new StrutturaBustaException("Header egov con più di un elemento Messaggio","Messaggio");
  521.                         }else{
  522.                             Eccezione ecc = new Eccezione();
  523.                             ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  524.                             ecc.setCodiceEccezione(CodiceErroreCooperazione.FORMATO_INTESTAZIONE_NON_CORRETTO);
  525.                             ecc.setRilevanza(LivelloRilevanza.ERROR);
  526.                             if(this.segnalazioneElementoPresentePiuVolte)
  527.                                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_FORMATO_INTESTAZIONE_NON_CORRETTO_POSIZIONE_MESSAGGIO+" "+CostantiProtocollo.ECCEZIONE_ELEMENTO_PRESENTE_PIU_VOLTE);
  528.                             else
  529.                                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_FORMATO_INTESTAZIONE_NON_CORRETTO_POSIZIONE_MESSAGGIO.toString());
  530.                             this.erroriValidazione.add(ecc);
  531.                         }
  532.                     }
  533.                     //}
  534.                 }
  535.                 //else if((child.getNodeName().equals(xmlns+"ProfiloTrasmissione"))){
  536.                 else if(SoapUtils.matchLocalName(messageFactory, child, "ProfiloTrasmissione", xmlns, SPCoopCostanti.NAMESPACE_EGOV)){
  537.                     if(localizzaSolamenteDatiIdentificativiMinimi==false){
  538.                         if(profiloTrasmissioneGiaTrovato==false){
  539.                             validazioneProfiloTrasmissione(messageFactory, child,xmlns);
  540.                             profiloTrasmissioneGiaTrovato = true;
  541.                         }else{
  542.                             if(this.spcoopProperties.isGenerazioneBustaErrore_strutturaMalformataHeaderProtocollo()==false){
  543.                                 throw new StrutturaBustaException("Header egov con più di un elemento ProfiloTrasmissione","ProfiloTrasmissione");
  544.                             }else{
  545.                                 Eccezione ecc = new Eccezione();
  546.                                 ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  547.                                 ecc.setCodiceEccezione(CodiceErroreCooperazione.PROFILO_TRASMISSIONE_PRESENTE_PIU_VOLTE);
  548.                                 ecc.setRilevanza(LivelloRilevanza.ERROR);
  549.                                 if(this.segnalazioneElementoPresentePiuVolte)
  550.                                     ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_PROFILO_TRASMISSIONE_NON_VALIDO_POSIZIONE+" "+CostantiProtocollo.ECCEZIONE_ELEMENTO_PRESENTE_PIU_VOLTE);
  551.                                 else
  552.                                     ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_PROFILO_TRASMISSIONE_NON_VALIDO_POSIZIONE.toString());
  553.                                 this.erroriValidazione.add(ecc);
  554.                             }
  555.                         }
  556.                     }
  557.                 }
  558.                 //else if((child.getNodeName().equals(xmlns+"Sequenza"))){
  559.                 else if(SoapUtils.matchLocalName(messageFactory, child, "Sequenza", xmlns, SPCoopCostanti.NAMESPACE_EGOV)){
  560.                     if(localizzaSolamenteDatiIdentificativiMinimi==false){
  561.                         if(sequenzaGiaTrovato==false){
  562.                             validazioneSequenza(messageFactory, child,xmlns);
  563.                             sequenzaGiaTrovato = true;
  564.                         }else{
  565.                             if(this.spcoopProperties.isGenerazioneBustaErrore_strutturaMalformataHeaderProtocollo()==false){
  566.                                 throw new StrutturaBustaException("Header egov con più di un elemento Sequenza","Sequenza");
  567.                             }else{
  568.                                 Eccezione ecc = new Eccezione();
  569.                                 ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  570.                                 ecc.setCodiceEccezione(CodiceErroreCooperazione.CONSEGNA_IN_ORDINE_PRESENTE_PIU_VOLTE);
  571.                                 ecc.setRilevanza(LivelloRilevanza.ERROR);
  572.                                 if(this.segnalazioneElementoPresentePiuVolte)
  573.                                     ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_SEQUENZA_NON_VALIDA_POSIZIONE+" "+CostantiProtocollo.ECCEZIONE_ELEMENTO_PRESENTE_PIU_VOLTE);
  574.                                 else
  575.                                     ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_SEQUENZA_NON_VALIDA_POSIZIONE.toString());
  576.                                 this.erroriValidazione.add(ecc);
  577.                             }
  578.                         }
  579.                     }
  580.                 }else{
  581.                     Eccezione ecc = new Eccezione();
  582.                     ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  583.                     ecc.setCodiceEccezione(CodiceErroreCooperazione.FORMATO_INTESTAZIONE_NON_CORRETTO);
  584.                     ecc.setRilevanza(LivelloRilevanza.ERROR);
  585.                     ecc.setDescrizione("Messaggio/child["+child.getNodeName()+"]");
  586.                     this.erroriValidazione.add(ecc);
  587.                 }
  588.             }

  590.             if(localizzaSolamenteDatiIdentificativiMinimi){
  591.                 // una volta letto il messaggio, anche minimo, e' possibile utilizzarlo.
  592.                 return true;
  593.             }
  594.             
  595.             // Controllo scadenza messaggio rispetto ora registrazione
  596.             if(this.spcoopProperties.isRepositoryBusteFiltraBusteScaduteRispettoOraRegistrazione() && (this.messaggioScaduto==false)){
  597.                 
  598.                 // Check su OraRegistrazione
  599.                 // Se correttamente formato, altrimenti segnalero' poi il problema
  600.                 Date oraRegistrazioneMinimaAccettata = new Date(DateManager.getTimeMillis()-(this.spcoopProperties.getIntervalloScadenzaBuste()*60*1000));
  601.                 /*System.out.println("BUSTA ["+this.busta.getOraRegistrazione().toString()
  602.                         +"]   MINIMA ["+oraRegistrazioneMinimaAccettata.toString()+"]");*/
  603.                 if(this.busta.getOraRegistrazione()!=null){
  604.                     if( this.busta.getOraRegistrazione().before(oraRegistrazioneMinimaAccettata)){
  605.                         this.log.error("OraRegistrazione portata nella busta ("+SPCoopUtils.getDate_eGovFormat(this.busta.getOraRegistrazione())+") più vecchia della data minima attesa ("+SPCoopUtils.getDate_eGovFormat(oraRegistrazioneMinimaAccettata)+") e scadenza non presente");
  606.                         Eccezione ecc = new Eccezione();
  607.                         ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  608.                         ecc.setCodiceEccezione(CodiceErroreCooperazione.MESSAGGIO_SCADUTO);
  609.                         ecc.setRilevanza(LivelloRilevanza.ERROR);
  610.                         ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_SCADENZA_NON_VALIDA_POSIZIONE.toString());
  611.                         this.erroriValidazione.add(ecc);
  612.                     }
  613.                 }
  614.                 
  615.                 // Check su id egov
  616.                 // Se correttamente formato, altrimenti segnalero' poi il problema
  617.                 if(this.busta.getID()!=null){
  618.                     String [] split = this.busta.getID().split("_");
  619.                     if(split != null && split.length == 5){
  620.                         Date dataIntoIDEgov = null;
  621.                         try{
  622.                             SimpleDateFormat dateformat = DateUtils.getSimpleDateFormatMinute();
  623.                             dataIntoIDEgov = dateformat.parse(split[3]+"_"+split[4]);
  624.                         }catch(Exception e){
  625.                             // ignore
  626.                         }
  627.                         if(dataIntoIDEgov!=null){
  628.                             //System.out.println("DATA IDEGOV BUSTA ["+dataIntoIDEgov.toString()
  629.                             //      +"]   MINIMA ["+oraRegistrazioneMinimaAccettata.toString()+"]");
  630.                             if( dataIntoIDEgov.before(oraRegistrazioneMinimaAccettata)){
  631.                                 this.log.error("Data presente nell'idEgov della busta ("+SPCoopUtils.getDate_eGovFormat(dataIntoIDEgov)+") più vecchia della data minima attesa ("+SPCoopUtils.getDate_eGovFormat(oraRegistrazioneMinimaAccettata)+") e scadenza non presente");
  632.                                 Eccezione ecc = new Eccezione();
  633.                                 ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  634.                                 ecc.setCodiceEccezione(CodiceErroreCooperazione.MESSAGGIO_SCADUTO);
  635.                                 ecc.setRilevanza(LivelloRilevanza.ERROR);
  636.                                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_SCADENZA_NON_VALIDA_POSIZIONE.toString());
  637.                                 this.erroriValidazione.add(ecc);
  638.                             }
  639.                         }
  640.                     }
  641.                 }
  642.             }

  644.             
  645.             // Altri Elementi
  646.             if(list.size()>1){
  647.                 boolean listaRiscontriGiaPresente = false;
  648.                 boolean listaTrasmissioniGiaPresente = false;
  649.                 boolean listaEccezioniGiaPresente = false;
  650.                 for(int i =1; i<list.size();i++){
  651.                     Node child = list.get(i);
  652.                     if(SoapUtils.matchLocalName(messageFactory, child, "IntestazioneMessaggio", xmlns, SPCoopCostanti.NAMESPACE_EGOV)){
  653.                         if(this.spcoopProperties.isGenerazioneBustaErrore_strutturaMalformataHeaderProtocollo()==false){
  654.                             throw new StrutturaBustaException("Header egov con più di un elemento IntestazioneMessaggio","IntestazioneMessaggio");
  655.                         }else{
  656.                             Eccezione ecc = new Eccezione();
  657.                             ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  658.                             ecc.setCodiceEccezione(CodiceErroreCooperazione.FORMATO_INTESTAZIONE_NON_CORRETTO);
  659.                             ecc.setRilevanza(LivelloRilevanza.ERROR);
  660.                             if(this.segnalazioneElementoPresentePiuVolte)
  661.                                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_FORMATO_INTESTAZIONE_NON_CORRETTO_POSIZIONE_INTESTAZIONE_MESSAGGIO+" "+CostantiProtocollo.ECCEZIONE_ELEMENTO_PRESENTE_PIU_VOLTE);
  662.                             else
  663.                                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_FORMATO_INTESTAZIONE_NON_CORRETTO_POSIZIONE_INTESTAZIONE_MESSAGGIO.toString());
  664.                             this.erroriValidazione.add(ecc);
  665.                         }
  666.                     }
  667.                     //else if((child.getNodeName().equals(xmlns+"ListaRiscontri"))){
  668.                     else if(SoapUtils.matchLocalName(messageFactory, child, "ListaRiscontri", xmlns, SPCoopCostanti.NAMESPACE_EGOV)){
  669.                         if(listaRiscontriGiaPresente==false){
  670.                             validazioneListaRiscontri(messageFactory, child,xmlns);
  671.                             listaRiscontriGiaPresente = true;
  672.                         }else{
  673.                             if(this.spcoopProperties.isGenerazioneBustaErrore_strutturaMalformataHeaderProtocollo()==false){
  674.                                 throw new StrutturaBustaException("Header egov con più di un elemento ListaRiscontri","ListaRiscontri");
  675.                             }else{
  676.                                 Eccezione ecc = new Eccezione();
  677.                                 ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  678.                                 ecc.setCodiceEccezione(CodiceErroreCooperazione.LISTA_RISCONTRI_PRESENTE_PIU_VOLTE);
  679.                                 ecc.setRilevanza(LivelloRilevanza.ERROR);
  680.                                 if(this.segnalazioneElementoPresentePiuVolte)
  681.                                     ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_RISCONTRI_NON_VALIDA_POSIZIONE+" "+CostantiProtocollo.ECCEZIONE_ELEMENTO_PRESENTE_PIU_VOLTE);
  682.                                 else
  683.                                     ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_RISCONTRI_NON_VALIDA_POSIZIONE.toString());
  684.                                 this.erroriValidazione.add(ecc);
  685.                             }
  686.                         }
  687.                     }
  688.                     //else if((child.getNodeName().equals(xmlns+"ListaTrasmissioni"))){
  689.                     else if(SoapUtils.matchLocalName(messageFactory, child, "ListaTrasmissioni", xmlns, SPCoopCostanti.NAMESPACE_EGOV)){
  690.                         if(listaTrasmissioniGiaPresente==false){
  691.                             validazioneListaTrasmissioni(messageFactory, child,xmlns);
  692.                             listaTrasmissioniGiaPresente = true;
  693.                         }else{
  694.                             if(this.spcoopProperties.isGenerazioneBustaErrore_strutturaMalformataHeaderProtocollo()==false){
  695.                                 throw new StrutturaBustaException("Header egov con più di un elemento ListaTrasmissioni","ListaTrasmissioni");
  696.                             }else{
  697.                                 Eccezione ecc = new Eccezione();
  698.                                 ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  699.                                 ecc.setCodiceEccezione(CodiceErroreCooperazione.LISTA_TRASMISSIONI_PRESENTE_PIU_VOLTE);
  700.                                 ecc.setRilevanza(LivelloRilevanza.ERROR);
  701.                                 if(this.segnalazioneElementoPresentePiuVolte)
  702.                                     ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_TRASMISSIONI_NON_VALIDA_POSIZIONE+" "+CostantiProtocollo.ECCEZIONE_ELEMENTO_PRESENTE_PIU_VOLTE);
  703.                                 else
  704.                                     ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_TRASMISSIONI_NON_VALIDA_POSIZIONE.toString());
  705.                                 this.erroriValidazione.add(ecc);
  706.                             }
  707.                         }
  708.                     }
  709.                     //else if((child.getNodeName().equals(xmlns+"ListaEccezioni"))){
  710.                     else if(SoapUtils.matchLocalName(messageFactory, child, "ListaEccezioni", xmlns, SPCoopCostanti.NAMESPACE_EGOV)){
  711.                         if(listaEccezioniGiaPresente==false){
  712.                             validazioneListaEccezioni(messageFactory, child,xmlns);
  713.                             listaEccezioniGiaPresente = true;
  714.                         }else{
  715.                             if(this.spcoopProperties.isGenerazioneBustaErrore_strutturaMalformataHeaderProtocollo()==false){
  716.                                 throw new StrutturaBustaException("Header egov con più di un elemento ListaEccezioni","ListaEccezioni");
  717.                             }else{
  718.                                 Eccezione ecc = new Eccezione();
  719.                                 ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  720.                                 ecc.setCodiceEccezione(CodiceErroreCooperazione.FORMATO_INTESTAZIONE_NON_CORRETTO);
  721.                                 ecc.setRilevanza(LivelloRilevanza.ERROR);
  722.                                 if(this.segnalazioneElementoPresentePiuVolte)
  723.                                     ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_ECCEZIONI_NON_VALIDA_POSIZIONE+" "+CostantiProtocollo.ECCEZIONE_ELEMENTO_PRESENTE_PIU_VOLTE);
  724.                                 else
  725.                                     ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_ECCEZIONI_NON_VALIDA_POSIZIONE.toString());
  726.                                 this.errorsTrovatiSullaListaEccezioni.add(ecc);
  727.                             }
  728.                         }
  729.                     }else{
  730.                         Eccezione ecc = new Eccezione();
  731.                         ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  732.                         ecc.setCodiceEccezione(CodiceErroreCooperazione.FORMATO_INTESTAZIONE_NON_CORRETTO);
  733.                         ecc.setRilevanza(LivelloRilevanza.ERROR);
  734.                         ecc.setDescrizione("Intestazione/child["+child.getNodeName()+"]");
  735.                         this.erroriValidazione.add(ecc);
  736.                     }
  737.                 }
  738.             } 

  740.             
  741.             if(this.spcoopProperties.isCheckTolleranzaDateFutureAttivo()){
  742.                 if(this.erroriValidazione.size()==0){
  743.                     // controllo che non vi siano date future
  744.                     validazioneDatePresentiRispettoDateFuture();
  745.                 }
  746.             }

  748.         } catch(StrutturaBustaException e) {
  749.             this.log.error("Struttura della busta non corretta: "+e.getMessage(),e);
  750.             this.msgErrore =  e.getMessage();
  751.             this.codiceErrore = CodiceErroreCooperazione.FORMATO_INTESTAZIONE_NON_CORRETTO;
  752.             return false; 
  753.         } catch(Exception e) {
  754.             Eccezione ecc = new Eccezione();
  755.             ecc.setContestoCodifica(ContestoCodificaEccezione.PROCESSAMENTO);
  756.             ecc.setCodiceEccezione(CodiceErroreCooperazione.ERRORE_GENERICO_PROCESSAMENTO_MESSAGGIO);
  757.             ecc.setRilevanza(LivelloRilevanza.ERROR);
  758.             ecc.setDescrizione("Errore di processamento durante la validazione sintattica");
  759.             this.erroriProcessamento.add(ecc);
  760.             this.log.error("Errore di processamento durante la validazione sintattica",e);
  761.         }

  763.         // una volta letto il messaggio e' possibile utilizzarlo.
  764.         return true;
  765.     }

  767.     
  768.     public SPCoopBustaRawContent getHeaderEGov_senzaControlli() throws ProtocolException{
  769.         try{    
  770.             // Estraggo header
  771.             if(this.headerSOAP==null)
  772.                 this.headerSOAP = this.msg.getSOAPHeader();
  773.             if(this.headerSOAP==null){
  774.                 throw new Exception("Analizzato un messaggio senza header");
  775.             }   
  776.             
  777.             // cerco la busta per l'actor
  778.             java.util.Iterator<?> it = this.headerSOAP.examineAllHeaderElements();
  779.             SOAPHeaderElement headerElementEGov = null;
  780.             while( it.hasNext()  ){

  782.                 // Test Header Element
  783.                 SOAPHeaderElement headerElement = (SOAPHeaderElement) it.next();

  785.                 //Controllo Actor
  786.                 if( SPCoopCostanti.ACTOR_EGOV.equals(headerElement.getActor()) == false  ){
  787.                     continue;
  788.                 }
  789.                 headerElementEGov = headerElement;
  790.             }
  791.             
  792.             if(headerElementEGov==null){
  793.                 // cerco la busta per il namespace
  794.                 it = this.headerSOAP.examineAllHeaderElements();
  795.                 while( it.hasNext()  ){

  797.                     // Test Header Element
  798.                     SOAPHeaderElement headerElement = (SOAPHeaderElement) it.next();

  800.                     //Controllo Namespace
  801.                     if( SPCoopCostanti.NAMESPACE_EGOV.equals(headerElement.getNamespaceURI()) == false  ){
  802.                         continue;
  803.                     }
  804.                     headerElementEGov = headerElement;
  805.                 }
  806.             }
  807.             
  808.             if(headerElementEGov==null){
  809.                 // header egov non trovato
  810.                 throw new Exception("Header eGov non presente");
  811.             }else{
  812.                 return new SPCoopBustaRawContent(headerElementEGov);
  813.             }
  814.         }catch(Exception e){
  815.             throw new ProtocolException("Lettura non riuscita: "+e.getMessage(),e);
  816.         }
  817.     }
  818.     
  819.     /**
  820.      * Metodo che si occupa di verificare che sia presente un header eGov nel SOAPHeader <var>SOAPHeader</var>.
  821.      * Per essere presente, un header eGov deve possedere almeno i seguenti elementi obbligatori :
  822.      * Intestazione con :
  823.      * <p>
  824.      * <ul>
  825.      * <li> IntestazioneMessaggio-Mittente-IdentificativoParte con tipo e valore
  826.      * <li> IntestazioneMessaggio-Destinatario-IdentificativoParte con tipo e valore
  827.      * <li> IntestazioneMessaggio-Messaggio-....
  828.      * </ul>
  829.      * <p>
  830.      * Se la verifica non ha successo, il metodo ritorna null, altrimenti l'header eGov presente (non estratto).
  831.      *
  832.      * @param header Header Soap in cui deve essere verificato la presenza di un header eGov.
  833.      * @return null se la verifica ha successo, altrimenti l'header eGov presente (non estratto).
  834.      * 
  835.      */
  836.     public SPCoopBustaRawContent getHeaderEGov(OpenSPCoop2MessageFactory messageFactory, SOAPHeader header) throws ProtocolException,StrutturaBustaException{
  837.         try{    

  839.             if(header == null)
  840.                 return null;
  841.             
  842.             // cerco la busta per l'actor
  843.             java.util.Iterator<?> it = header.examineAllHeaderElements();
  844.             SOAPHeaderElement headerElementEGov = null;
  845.             StringBuilder bf = new StringBuilder();
  846.             while( it.hasNext()  ){

  848.                 // Test Header Element
  849.                 SOAPHeaderElement headerElement = (SOAPHeaderElement) it.next();

  851.                 //Controllo Actor
  852.                 try{
  853.                     bf.append("Check ACTOR Atteso["+SPCoopCostanti.ACTOR_EGOV+"]==["+headerElement.getActor()+"]=["+SPCoopCostanti.ACTOR_EGOV.equals(headerElement.getActor())+"]\n");
  854.                 }catch(Exception e){
  855.                     // ignore
  856.                 }

  858.                 if( SPCoopCostanti.ACTOR_EGOV.equals(headerElement.getActor()) == false  ){
  859.                     continue;
  860.                 }
  861.                 bf.append("FIND!\n");
  862.                 headerElementEGov = headerElement;
  863.             }
  864.             
  865.             if(headerElementEGov==null){
  866.                 bf.append("NOT FOUND TRAMITE ACTOR!\n");
  867.                 // cerco la busta per il namespace
  868.                 it = header.examineAllHeaderElements();
  869.                 while( it.hasNext()  ){

  871.                     // Test Header Element
  872.                     SOAPHeaderElement headerElement = (SOAPHeaderElement) it.next();

  874.                     //Controllo Namespace
  875.                     try{
  876.                         bf.append("Check NAMESPACE Atteso["+SPCoopCostanti.NAMESPACE_EGOV+"]==["+headerElement.getNamespaceURI()+"]=["+SPCoopCostanti.NAMESPACE_EGOV.equals(headerElement.getNamespaceURI())+"]\n");
  877.                     }catch(Exception e){
  878.                         // ignore
  879.                     }
  880.                     if( SPCoopCostanti.NAMESPACE_EGOV.equals(headerElement.getNamespaceURI()) == false  ){
  881.                         continue;
  882.                     }
  883.                     bf.append("FIND!\n");
  884.                     headerElementEGov = headerElement;
  885.                 }
  886.             }
  887.             
  888.             if(headerElementEGov==null){
  889.                 // header egov non trovato
  890.                 String msgHeader = "";
  891.                 try{
  892.                     msgHeader = " header-soap: "+messageFactory.createEmptyMessage(MessageType.SOAP_11,MessageRole.NONE).getAsString(header, false);
  893.                 }catch(Exception e){
  894.                     // ignore
  895.                 }
  896.                 throw new Exception("Header eGov non presente ("+bf.toString()+")"+msgHeader);
  897.             }
  898.             
  899.             // Preparazione busta di default per eventuale eccezione
  900.             Busta errore = new Busta(this.protocolFactory.getProtocol());
  901.             errore.setTipoMittente(this.spcoopProperties.getKeywordTipoMittenteSconosciuto());
  902.             errore.setMittente(this.spcoopProperties.getKeywordMittenteSconosciuto());
  903.             errore.setIdentificativoPortaMittente(this.traduttore.getIdentificativoPortaDefault(new IDSoggetto(errore.getTipoMittente(), errore.getMittente())));
  904.             errore.setTipoDestinatario(this.spcoopProperties.getKeywordTipoMittenteSconosciuto());
  905.             errore.setDestinatario(this.spcoopProperties.getKeywordMittenteSconosciuto());
  906.             errore.setIdentificativoPortaDestinatario(this.traduttore.getIdentificativoPortaDefault(new IDSoggetto(errore.getTipoDestinatario(), errore.getDestinatario())));
  907.             
  908.             // Controllo presenza più di un header eGov
  909.             if(this.existsMoreHeaderEGov()){
  910.                 errore.addEccezione(Eccezione.getEccezioneValidazione(CodiceErroreCooperazione.FORMATO_NON_CORRETTO, 
  911.                         "Più di un header e-Gov presente",
  912.                         this.protocolFactory));
  913.                 this.bustaErroreHeaderIntestazione = errore;
  914.                 throw new Exception("Più di un header e-Gov presente"); 
  915.             }
  916.             
  917.             // Prefix eGov
  918.             String xmlns = headerElementEGov.getPrefix();
  919.             if(xmlns == null){ 
  920.                 xmlns = "";
  921.             }else if(!xmlns.equals("")){
  922.                 xmlns = xmlns + ":";
  923.             }
  924.             
  925.             // Controllo presenza elementi obbligatori che contraddistingono un header eGov: Intestazione
  926.             //if(headerElementEGov.getNodeName().equals(xmlns+"Intestazione") == false){
  927.             if(SoapUtils.matchLocalName(messageFactory, headerElementEGov, "Intestazione", xmlns, SPCoopCostanti.NAMESPACE_EGOV) == false ){
  928.                 this.bustaErroreHeaderIntestazione = errore;
  929.                 this.bustaErroreHeaderIntestazione.addEccezione(Eccezione.getEccezioneValidazione(CodiceErroreCooperazione.FORMATO_NON_CORRETTO, 
  930.                         SPCoopCostantiPosizioneEccezione.ECCEZIONE_FORMATO_NON_CORRETTO_POSIZIONE.toString(),this.protocolFactory));
  931.                 throw new Exception("Header eGov senza header intestazione");
  932.             }

  934.             // Controllo elementi che contraddistingono un header eGov : Intestazione Messaggio
  935.             List<Node> list = SoapUtils.getNotEmptyChildNodes(messageFactory, headerElementEGov);
  936.             if(list==null || list.size() == 0){ 
  937.                 this.bustaErroreHeaderIntestazione = errore;
  938.                 this.bustaErroreHeaderIntestazione.addEccezione(Eccezione.getEccezioneValidazione(CodiceErroreCooperazione.FORMATO_INTESTAZIONE_NON_CORRETTO, 
  939.                         SPCoopCostantiPosizioneEccezione.ECCEZIONE_FORMATO_INTESTAZIONE_NON_CORRETTO_POSIZIONE_INTESTAZIONE_MESSAGGIO.toString(),this.protocolFactory));
  940.                 throw new Exception("Header eGov con header intestazione senza elementi interni tra cui IntestazioneMessaggio");
  941.             } 
  942.             Node intestazioneMsg = list.get(0);
  943.             //if( (intestazioneMsg==null) ||  (!(intestazioneMsg.getNodeName().equals(xmlns+"IntestazioneMessaggio")))  ) {
  944.             if( (intestazioneMsg==null) ||   (!SoapUtils.matchLocalName(messageFactory, intestazioneMsg, "IntestazioneMessaggio", xmlns, SPCoopCostanti.NAMESPACE_EGOV)) ) {
  945.                 this.bustaErroreHeaderIntestazione = errore;
  946.                 this.bustaErroreHeaderIntestazione.addEccezione(Eccezione.getEccezioneValidazione(CodiceErroreCooperazione.FORMATO_INTESTAZIONE_NON_CORRETTO, 
  947.                         SPCoopCostantiPosizioneEccezione.ECCEZIONE_FORMATO_INTESTAZIONE_NON_CORRETTO_POSIZIONE_INTESTAZIONE_MESSAGGIO.toString(),this.protocolFactory));
  948.                 throw new Exception("Header eGov con header intestazione che possiede first child ["+(intestazioneMsg!=null ? intestazioneMsg.getNodeName() : "null")+"] diverso da IntestazioneMessaggio");
  949.             }
  950.             
  951.             List<Node> intestMsgChild = SoapUtils.getNotEmptyChildNodes(messageFactory, intestazioneMsg);
  952.             
  953.             // Controllo elementi principali
  954.             Node mittente = null;
  955.             Node destinatario = null;
  956.             Node messaggio = null;
  957.             for(int i=0;i<intestMsgChild.size();i++){
  958.                 Node child = intestMsgChild.get(i);
  959.                 if(child==null){
  960.                     this.log.info("Elemento null");
  961.                 }else if(child.getNodeName()==null){
  962.                     this.log.info("Elemento child null");
  963.                 }
  964.                 if(child!=null && child.getNodeName()!=null){
  965.                     //if( (mittente==null) && ((child.getNodeName().equals(xmlns+"Mittente")))){
  966.                     if( (mittente==null) && (SoapUtils.matchLocalName(messageFactory, child, "Mittente", xmlns, SPCoopCostanti.NAMESPACE_EGOV))){
  967.                         mittente = child; 
  968.                     }
  969.                     //else if( (destinatario==null) && ((child.getNodeName().equals(xmlns+"Destinatario")))){
  970.                     else if( (destinatario==null) && (SoapUtils.matchLocalName(messageFactory, child, "Destinatario", xmlns, SPCoopCostanti.NAMESPACE_EGOV))){
  971.                         destinatario = child;
  972.                     }
  973.                     //else if( (messaggio==null) && ((child.getNodeName().equals(xmlns+"Messaggio")))){
  974.                     else if( (messaggio==null) && (SoapUtils.matchLocalName(messageFactory, child, "Messaggio", xmlns, SPCoopCostanti.NAMESPACE_EGOV))){
  975.                         messaggio = child;
  976.                     }
  977.                 }
  978.             }
  979.             
  980.             boolean eccezioneStrutturaMittente = false;
  981.             boolean eccezioneStrutturaDestinatario = false;
  982.             boolean eccezioneStrutturaMessaggio = false;
  983.             
  984.             // controllo mittente
  985.             if(mittente==null){
  986.                 errore.addEccezione(Eccezione.getEccezioneValidazione(CodiceErroreCooperazione.MITTENTE_NON_PRESENTE, 
  987.                         SPCoopCostantiPosizioneEccezione.ECCEZIONE_MITTENTE_SCONOSCIUTO_POSIZIONE.toString(),this.protocolFactory));
  988.                 eccezioneStrutturaMittente = true;
  989.             }else{
  990.                 List<Node> headerMittente = SoapUtils.getNotEmptyChildNodes(messageFactory, mittente); // identificativoParte mitt
  991.                 if( (headerMittente==null) || (headerMittente.size() == 0) ){
  992.                     errore.addEccezione(Eccezione.getEccezioneValidazione(CodiceErroreCooperazione.MITTENTE_NON_PRESENTE, 
  993.                             SPCoopCostantiPosizioneEccezione.ECCEZIONE_MITTENTE_SCONOSCIUTO_POSIZIONE_IDENTIFICATIVO_PARTE.toString(),this.protocolFactory));
  994.                     eccezioneStrutturaMittente = true;
  995.                 } else {
  996.                     for(int i=0; i<headerMittente.size(); i++){
  997.                         Node idParteMittente = headerMittente.get(i);
  998.                         //if( !(idParteMittente.getNodeName().equals(xmlns+"IdentificativoParte"))  ){ 
  999.                         if( !(SoapUtils.matchLocalName(messageFactory, idParteMittente, "IdentificativoParte", xmlns, SPCoopCostanti.NAMESPACE_EGOV))  ){ 
  1000.                             errore.addEccezione(Eccezione.getEccezioneValidazione(CodiceErroreCooperazione.MITTENTE_NON_PRESENTE, 
  1001.                                     SPCoopCostantiPosizioneEccezione.ECCEZIONE_MITTENTE_SCONOSCIUTO_POSIZIONE_IDENTIFICATIVO_PARTE.toString(),this.protocolFactory));
  1002.                             eccezioneStrutturaMittente = true;
  1003.                             break;
  1004.                         }
  1005.                         List<Node> valueIDParteMitt = SoapUtils.getNotEmptyChildNodes(messageFactory, idParteMittente);
  1006.                         if( (valueIDParteMitt==null) || (valueIDParteMitt.size() == 0) || (valueIDParteMitt.size() > 1) ){ 
  1007.                             errore.addEccezione(Eccezione.getEccezioneValidazione(CodiceErroreCooperazione.MITTENTE_NON_VALORIZZATO, 
  1008.                                     SPCoopCostantiPosizioneEccezione.ECCEZIONE_MITTENTE_SCONOSCIUTO_POSIZIONE_IDENTIFICATIVO_PARTE.toString(),this.protocolFactory));
  1009.                             eccezioneStrutturaMittente = false;
  1010.                             break;
  1011.                         } 
  1012.                         String mittenteValue = null;
  1013.                         try{
  1014.                             mittenteValue = valueIDParteMitt.get(0).getNodeValue();
  1015.                             if(mittenteValue==null)
  1016.                                 throw new Exception("mittente is null");
  1017.                             //log.info("Value identificativo parte ["+valueIDParteMitt.item(0).getNodeValue()+"]");
  1018.                         } catch(Exception e) {
  1019.                             errore.addEccezione(Eccezione.getEccezioneValidazione(CodiceErroreCooperazione.MITTENTE_NON_VALORIZZATO, 
  1020.                                     SPCoopCostantiPosizioneEccezione.ECCEZIONE_MITTENTE_SCONOSCIUTO_POSIZIONE_IDENTIFICATIVO_PARTE.toString(),this.protocolFactory));
  1021.                             eccezioneStrutturaMittente = false;
  1022.                             break;
  1023.                         }
  1024.                         String tipoMittente = null;
  1025.                         Node hrefFindMitt = null;
  1026.                         if(this.readQualifiedAttribute){
  1027.                             hrefFindMitt = SoapUtils.getQualifiedAttributeNode(messageFactory, idParteMittente, "tipo", SPCoopCostanti.NAMESPACE_EGOV);
  1028.                         }else{
  1029.                             hrefFindMitt = SoapUtils.getAttributeNode(messageFactory, idParteMittente, "tipo");
  1030.                         }
  1031.                         if(hrefFindMitt!=null){
  1032.                             try{
  1033.                                 tipoMittente = hrefFindMitt.getNodeValue();
  1034.                                 if(tipoMittente == null)
  1035.                                     throw new Exception("tipo non definito");
  1036.                                 //log.info("Value identificativo parte ["+hrefFindMitt.getNodeValue()+"]");
  1037.                             } catch(Exception e) {
  1038.                                 errore.addEccezione(Eccezione.getEccezioneValidazione(CodiceErroreCooperazione.TIPO_MITTENTE_NON_VALIDO, 
  1039.                                         SPCoopCostantiPosizioneEccezione.ECCEZIONE_MITTENTE_SCONOSCIUTO_POSIZIONE_IDENTIFICATIVO_PARTE_TIPO.toString(),this.protocolFactory));
  1040.                                 eccezioneStrutturaMittente = true;
  1041.                                 break;
  1042.                             }
  1043.                         }else{
  1044.                             errore.addEccezione(Eccezione.getEccezioneValidazione(CodiceErroreCooperazione.TIPO_MITTENTE_NON_PRESENTE, 
  1045.                                     SPCoopCostantiPosizioneEccezione.ECCEZIONE_MITTENTE_SCONOSCIUTO_POSIZIONE_IDENTIFICATIVO_PARTE_TIPO.toString(),this.protocolFactory));
  1046.                             eccezioneStrutturaMittente = true;
  1047.                             break;
  1048.                         }   
  1049.                         if(i==0){
  1050.                             if(tipoMittente!=null) {
  1051.                                 try {
  1052.                                     errore.setTipoMittente(this.traduttore.toRegistryOrganizationType(tipoMittente));
  1053.                                 }catch(Exception e) {
  1054.                                     errore.setTipoMittente(tipoMittente); // senza traduzione
  1055.                                 }
  1056.                             }
  1057.                             errore.setMittente(mittenteValue);
  1058.                         }else{
  1059.                             //errore.addEccezione(Eccezione.getEccezioneValidazione(Costanti.ECCEZIONE_MITTENTE_SCONOSCIUTO, 
  1060.                             //      Costanti.ECCEZIONE_MITTENTE_SCONOSCIUTO_POSIZIONE_IDENTIFICATIVO_PARTE+":"+tipoMittente+"/"+mittenteValue+" (busta con più di un mittente non gestita)" ));
  1061.                             errore.addEccezione(Eccezione.getEccezioneValidazione(CodiceErroreCooperazione.MITTENTE_PRESENTE_PIU_VOLTE, 
  1062.                                             SPCoopCostantiPosizioneEccezione.ECCEZIONE_MITTENTE_SCONOSCIUTO_POSIZIONE_IDENTIFICATIVO_PARTE.toString(),this.protocolFactory));
  1063.                             eccezioneStrutturaMittente = false;
  1064.                         }
  1065.                     }
  1066.                 }
  1067.             }
  1068.             
  1069.             // controllo destinatario
  1070.             if(destinatario==null){
  1071.                 errore.addEccezione(Eccezione.getEccezioneValidazione(CodiceErroreCooperazione.DESTINATARIO_NON_PRESENTE, 
  1072.                         SPCoopCostantiPosizioneEccezione.ECCEZIONE_DESTINATARIO_SCONOSCIUTO_POSIZIONE.toString(),this.protocolFactory));
  1073.                 eccezioneStrutturaDestinatario = true;
  1074.             }else{
  1075.                 List<Node> headerDestinatario = SoapUtils.getNotEmptyChildNodes(messageFactory, destinatario); // identificativoParte dest
  1076.                 if( (headerDestinatario==null) || (headerDestinatario.size() == 0) ){
  1077.                     errore.addEccezione(Eccezione.getEccezioneValidazione(CodiceErroreCooperazione.DESTINATARIO_NON_PRESENTE, 
  1078.                             SPCoopCostantiPosizioneEccezione.ECCEZIONE_DESTINATARIO_SCONOSCIUTO_POSIZIONE_IDENTIFICATIVO_PARTE.toString(),this.protocolFactory));
  1079.                     eccezioneStrutturaDestinatario = true;
  1080.                 } else {
  1081.                     for(int i=0; i<headerDestinatario.size(); i++){
  1082.                         Node idParteDestinatario = headerDestinatario.get(i);
  1083.                         //if( !(idParteDestinatario.getNodeName().equals(xmlns+"IdentificativoParte"))  ){
  1084.                         if( !(SoapUtils.matchLocalName(messageFactory, idParteDestinatario, "IdentificativoParte", xmlns, SPCoopCostanti.NAMESPACE_EGOV))  ){ 
  1085.                             errore.addEccezione(Eccezione.getEccezioneValidazione(CodiceErroreCooperazione.DESTINATARIO_NON_VALIDO, 
  1086.                                     SPCoopCostantiPosizioneEccezione.ECCEZIONE_DESTINATARIO_SCONOSCIUTO_POSIZIONE_IDENTIFICATIVO_PARTE.toString(),this.protocolFactory));
  1087.                             eccezioneStrutturaDestinatario = true;
  1088.                             break;
  1089.                         }
  1090.                         List<Node> valueIDParteDest = SoapUtils.getNotEmptyChildNodes(messageFactory, idParteDestinatario);
  1091.                         if( (valueIDParteDest==null) || (valueIDParteDest.size() == 0) || (valueIDParteDest.size() > 1) ){ 
  1092.                             errore.addEccezione(Eccezione.getEccezioneValidazione(CodiceErroreCooperazione.DESTINATARIO_NON_VALIDO, 
  1093.                                     SPCoopCostantiPosizioneEccezione.ECCEZIONE_DESTINATARIO_SCONOSCIUTO_POSIZIONE_IDENTIFICATIVO_PARTE.toString(),this.protocolFactory));
  1094.                             eccezioneStrutturaDestinatario = false;
  1095.                             break;
  1096.                         } 
  1097.                         String destinatarioValue = null;
  1098.                         try{
  1099.                             destinatarioValue = valueIDParteDest.get(0).getNodeValue();
  1100.                             if(destinatarioValue==null)
  1101.                                 throw new Exception("destinatario is null");
  1102.                             //log.info("Value identificativo parte ["+valueIDParteDest.item(0).getNodeValue()+"]");
  1103.                         } catch(Exception e) {
  1104.                             errore.addEccezione(Eccezione.getEccezioneValidazione(CodiceErroreCooperazione.DESTINATARIO_NON_VALORIZZATO, 
  1105.                                     SPCoopCostantiPosizioneEccezione.ECCEZIONE_DESTINATARIO_SCONOSCIUTO_POSIZIONE_IDENTIFICATIVO_PARTE.toString(),this.protocolFactory));
  1106.                             eccezioneStrutturaDestinatario = false;
  1107.                             break;
  1108.                         }
  1109.                         String tipoDestinatario = null;
  1110.                         Node hrefFindDest = null;
  1111.                         if(this.readQualifiedAttribute){
  1112.                             hrefFindDest = SoapUtils.getQualifiedAttributeNode(messageFactory, idParteDestinatario, "tipo", SPCoopCostanti.NAMESPACE_EGOV);
  1113.                         }else{
  1114.                             hrefFindDest = SoapUtils.getAttributeNode(messageFactory, idParteDestinatario, "tipo");
  1115.                         }
  1116.                         if(hrefFindDest!=null){
  1117.                             try{
  1118.                                 tipoDestinatario = hrefFindDest.getNodeValue();
  1119.                                 if(tipoDestinatario == null)
  1120.                                     throw new Exception("tipo non definito");
  1121.                                 //log.info("Value identificativo parte ["+hrefFindDest.getNodeValue()+"]");
  1122.                             } catch(Exception e) {
  1123.                                 errore.addEccezione(Eccezione.getEccezioneValidazione(CodiceErroreCooperazione.TIPO_DESTINATARIO_NON_VALIDO, 
  1124.                                         SPCoopCostantiPosizioneEccezione.ECCEZIONE_DESTINATARIO_SCONOSCIUTO_POSIZIONE_IDENTIFICATIVO_PARTE_TIPO.toString(),this.protocolFactory));
  1125.                                 eccezioneStrutturaDestinatario = true;
  1126.                                 break;
  1127.                             }
  1128.                         }else{
  1129.                             errore.addEccezione(Eccezione.getEccezioneValidazione(CodiceErroreCooperazione.TIPO_DESTINATARIO_NON_PRESENTE, 
  1130.                                     SPCoopCostantiPosizioneEccezione.ECCEZIONE_DESTINATARIO_SCONOSCIUTO_POSIZIONE_IDENTIFICATIVO_PARTE_TIPO.toString(),this.protocolFactory));
  1131.                             eccezioneStrutturaDestinatario = true;
  1132.                             break;
  1133.                         }   
  1134.                         if(i==0){
  1135.                             if(tipoDestinatario!=null) {
  1136.                                 try {
  1137.                                     errore.setTipoDestinatario(this.traduttore.toRegistryOrganizationType(tipoDestinatario));
  1138.                                 }catch(Exception e) {
  1139.                                     errore.setTipoDestinatario(tipoDestinatario); // senza traduzione
  1140.                                 }
  1141.                             }
  1142.                             errore.setDestinatario(destinatarioValue);
  1143.                         }else{
  1144.                             //errore.addEccezione(Eccezione.getEccezioneValidazione(Costanti.ECCEZIONE_DESTINATARIO_SCONOSCIUTO, 
  1145.                             //      Costanti.ECCEZIONE_DESTINATARIO_SCONOSCIUTO_POSIZIONE_IDENTIFICATIVO_PARTE+":"+tipoDestinatario+"/"+destinatarioValue+" (busta con più di un destinatario non gestita)" ));
  1146.                             errore.addEccezione(Eccezione.getEccezioneValidazione(CodiceErroreCooperazione.DESTINATARIO_PRESENTE_PIU_VOLTE, 
  1147.                                     SPCoopCostantiPosizioneEccezione.ECCEZIONE_DESTINATARIO_SCONOSCIUTO_POSIZIONE_IDENTIFICATIVO_PARTE.toString(),this.protocolFactory));
  1148.                             eccezioneStrutturaDestinatario = false;
  1149.                         }
  1150.                     }
  1151.                 }
  1152.             }
  1153.             
  1154.             // controllo messaggio
  1155.             if(messaggio==null){
  1156.                 errore.addEccezione(Eccezione.getEccezioneValidazione(CodiceErroreCooperazione.FORMATO_INTESTAZIONE_NON_CORRETTO, 
  1157.                         SPCoopCostantiPosizioneEccezione.ECCEZIONE_FORMATO_INTESTAZIONE_NON_CORRETTO_POSIZIONE_MESSAGGIO.toString(),this.protocolFactory));
  1158.                 eccezioneStrutturaMessaggio = true;
  1159.             }else{
  1160.                 List<Node> contenutoMsg = SoapUtils.getNotEmptyChildNodes(messageFactory, messaggio);
  1161.                 if( (contenutoMsg.size() <= 0)){
  1162.                     errore.addEccezione(Eccezione.getEccezioneValidazione(CodiceErroreCooperazione.IDENTIFICATIVO_MESSAGGIO_NON_PRESENTE, 
  1163.                             SPCoopCostantiPosizioneEccezione.ECCEZIONE_ID_MESSAGGIO_NON_DEFINITO_POSIZIONE.toString(),this.protocolFactory));
  1164.                     eccezioneStrutturaMessaggio = true;
  1165.                     
  1166.                 }else{
  1167.                     String identificatore = null;
  1168.                     boolean identificatoreTrovato = false;
  1169.                     for(int j =0; j<contenutoMsg.size();j++){
  1170.                         Node childMsg = contenutoMsg.get(j);
  1171.                         //if((childMsg.getNodeName().equals(xmlns+"Identificatore"))){
  1172.                         if(SoapUtils.matchLocalName(messageFactory, childMsg, "Identificatore", xmlns, SPCoopCostanti.NAMESPACE_EGOV)){
  1173.                             identificatoreTrovato = true;
  1174.                             if (SoapUtils.getNotEmptyChildNodes(messageFactory, childMsg).size() != 1){
  1175.                                 errore.addEccezione(Eccezione.getEccezioneValidazione(CodiceErroreCooperazione.IDENTIFICATIVO_MESSAGGIO_NON_VALORIZZATO, 
  1176.                                         SPCoopCostantiPosizioneEccezione.ECCEZIONE_ID_MESSAGGIO_NON_DEFINITO_POSIZIONE.toString(),this.protocolFactory));
  1177.                             }else{
  1178.                                 try{
  1179.                                     identificatore = SoapUtils.getNotEmptyChildNodes(messageFactory, childMsg).get(0).getNodeValue();
  1180.                                 } catch(Exception e) {
  1181.                                     // ignore
  1182.                                 }
  1183.                             }
  1184.                             break;
  1185.                         }
  1186.                     }
  1187.                     if(identificatoreTrovato==false){
  1188.                         errore.addEccezione(Eccezione.getEccezioneValidazione(CodiceErroreCooperazione.IDENTIFICATIVO_MESSAGGIO_NON_PRESENTE, 
  1189.                                 SPCoopCostantiPosizioneEccezione.ECCEZIONE_ID_MESSAGGIO_NON_DEFINITO_POSIZIONE.toString(),this.protocolFactory));
  1190.                         eccezioneStrutturaMessaggio = true;
  1191.                     }else if(identificatore==null){
  1192.                         errore.addEccezione(Eccezione.getEccezioneValidazione(CodiceErroreCooperazione.IDENTIFICATIVO_MESSAGGIO_NON_PRESENTE, 
  1193.                                 SPCoopCostantiPosizioneEccezione.ECCEZIONE_ID_MESSAGGIO_NON_DEFINITO_POSIZIONE.toString(),this.protocolFactory));
  1194.                         eccezioneStrutturaMessaggio = false;
  1195.                     }else{
  1196.                         errore.setID(identificatore);
  1197.                     }
  1198.                 }
  1199.             }
  1200.             
  1201.                 
  1202.             
  1203.             // report
  1204.             if(errore.sizeListaEccezioni()>0){
  1205.                 
  1206.                 if(this.spcoopProperties.isGenerazioneBustaErrore_strutturaMalformataHeaderProtocollo()==false && 
  1207.                         ((eccezioneStrutturaMittente) || (eccezioneStrutturaDestinatario) || (eccezioneStrutturaMessaggio))
  1208.                     ){
  1209.                     Eccezione ec = errore.getEccezione(0);
  1210.                     throw new StrutturaBustaException("Header egov con struttura errata, "+ec.getDescrizione(this.protocolFactory),ec.getDescrizione(this.protocolFactory).replaceAll("/", ""));
  1211.                 }   
  1212.                 
  1213.                 // Leggo eventuali altri valori presenti
  1214.                 Node servizio = null;
  1215.                 Node azione = null;
  1216.                 Node profiloCollaborazione = null;
  1217.                 Node collaborazione = null;
  1218.                 Node profiloTrasmissione = null;
  1219.                 Node sequenza = null;
  1220.                 for(int i=0;i<intestMsgChild.size();i++){
  1221.                     Node child = intestMsgChild.get(i);
  1222.                     //if( (mittente==null) && ((child.getNodeName().equals(xmlns+"Mittente")))){
  1223.                     if( (mittente==null) && ((SoapUtils.matchLocalName(messageFactory, child, "Mittente", xmlns, SPCoopCostanti.NAMESPACE_EGOV)))){
  1224.                         mittente = child; 
  1225.                     }
  1226.                     //else if( (destinatario==null) && ((child.getNodeName().equals(xmlns+"Destinatario")))){
  1227.                     else if( (destinatario==null) && ((SoapUtils.matchLocalName(messageFactory, child, "Destinatario", xmlns, SPCoopCostanti.NAMESPACE_EGOV)))){
  1228.                         destinatario = child;
  1229.                     }
  1230.                     //else if( (servizio==null) && ((child.getNodeName().equals(xmlns+"Servizio")))){
  1231.                     else if( (servizio==null) && ((SoapUtils.matchLocalName(messageFactory, child, "Servizio", xmlns, SPCoopCostanti.NAMESPACE_EGOV)))){
  1232.                         servizio = child;
  1233.                     }
  1234.                     //else if( (azione==null) && ((child.getNodeName().equals(xmlns+"Azione")))){
  1235.                     else if( (azione==null) && ((SoapUtils.matchLocalName(messageFactory, child, "Azione", xmlns, SPCoopCostanti.NAMESPACE_EGOV)))){
  1236.                         azione = child;
  1237.                     }
  1238.                     //else if( (profiloCollaborazione==null) && ((child.getNodeName().equals(xmlns+"ProfiloCollaborazione")))){
  1239.                     else if( (profiloCollaborazione==null) && ((SoapUtils.matchLocalName(messageFactory, child, "ProfiloCollaborazione", xmlns, SPCoopCostanti.NAMESPACE_EGOV)))){
  1240.                         profiloCollaborazione = child;
  1241.                     }
  1242.                     //else if( (collaborazione==null) && ((child.getNodeName().equals(xmlns+"Collaborazione")))){
  1243.                     else if( (collaborazione==null) && ((SoapUtils.matchLocalName(messageFactory, child, "Collaborazione", xmlns, SPCoopCostanti.NAMESPACE_EGOV)))){
  1244.                         collaborazione = child;
  1245.                     }
  1246.                     //else if( (profiloTrasmissione==null) && ((child.getNodeName().equals(xmlns+"ProfiloTrasmissione")))){
  1247.                     else if( (profiloTrasmissione==null) && ((SoapUtils.matchLocalName(messageFactory, child, "ProfiloTrasmissione", xmlns, SPCoopCostanti.NAMESPACE_EGOV)))){
  1248.                         profiloTrasmissione = child;
  1249.                     }
  1250.                     //else if( (sequenza==null) && ((child.getNodeName().equals(xmlns+"Sequenza")))){
  1251.                     else if( (sequenza==null) && ((SoapUtils.matchLocalName(messageFactory, child, "Sequenza", xmlns, SPCoopCostanti.NAMESPACE_EGOV)))){
  1252.                         sequenza = child;
  1253.                     }
  1254.                 }
  1255.                 
  1256.                 // Mittente
  1257.                 if(mittente!=null){
  1258.                     try{
  1259.                         List<Node> headerMittente = SoapUtils.getNotEmptyChildNodes(messageFactory, mittente);
  1260.                         Node idParteMittente = headerMittente.get(0);
  1261.                         errore.setMittente(SoapUtils.getNotEmptyChildNodes(messageFactory, idParteMittente).get(0).getNodeValue());
  1262.                     }catch(Exception e){
  1263.                         // ignore
  1264.                     }
  1265.                     try{
  1266.                         List<Node> headerMittente = SoapUtils.getNotEmptyChildNodes(messageFactory, mittente);
  1267.                         Node idParteMittente = headerMittente.get(0);
  1268.                         Node hrefFindMitt = null;
  1269.                         if(this.readQualifiedAttribute){
  1270.                             hrefFindMitt = SoapUtils.getQualifiedAttributeNode(messageFactory, idParteMittente, "tipo", SPCoopCostanti.NAMESPACE_EGOV);
  1271.                         }else{
  1272.                             hrefFindMitt = SoapUtils.getAttributeNode(messageFactory, idParteMittente, "tipo");
  1273.                         }
  1274.                         String itValue = hrefFindMitt.getNodeValue();
  1275.                         if(itValue!=null) {
  1276.                             try {
  1277.                                 errore.setTipoMittente(this.traduttore.toRegistryOrganizationType(itValue));
  1278.                             }catch(Exception e) {
  1279.                                 errore.setTipoMittente(itValue); // senza traduzione
  1280.                             }
  1281.                         }
  1282.                     }catch(Exception e){
  1283.                         // ignore
  1284.                     }
  1285.                     try{
  1286.                         List<Node> headerMittente = SoapUtils.getNotEmptyChildNodes(messageFactory, mittente);
  1287.                         Node idParteMittente = headerMittente.get(0);
  1288.                         Node hrefFindMitt = null;
  1289.                         if(this.readQualifiedAttribute){
  1290.                             hrefFindMitt = SoapUtils.getQualifiedAttributeNode(messageFactory, idParteMittente, "indirizzoTelematico", SPCoopCostanti.NAMESPACE_EGOV);
  1291.                         }else{
  1292.                             hrefFindMitt = SoapUtils.getAttributeNode(messageFactory, idParteMittente, "indirizzoTelematico");
  1293.                         }
  1294.                         String itValue = hrefFindMitt.getNodeValue();
  1295.                         errore.setIndirizzoMittente(itValue);
  1296.                     }catch(Exception e){
  1297.                         // ignore
  1298.                     }
  1299.                 }
  1300.                 
  1301.                 // Destinatario
  1302.                 if(destinatario!=null){
  1303.                     try{
  1304.                         List<Node> headerDest = SoapUtils.getNotEmptyChildNodes(messageFactory, destinatario);
  1305.                         Node idParteDest = headerDest.get(0);
  1306.                         errore.setDestinatario(SoapUtils.getNotEmptyChildNodes(messageFactory, idParteDest).get(0).getNodeValue());
  1307.                     }catch(Exception e){
  1308.                         // ignore
  1309.                     }
  1310.                     try{
  1311.                         List<Node> headerDest = SoapUtils.getNotEmptyChildNodes(messageFactory, destinatario);
  1312.                         Node idParteDest = headerDest.get(0);
  1313.                         Node hrefFindDest = null;
  1314.                         if(this.readQualifiedAttribute){
  1315.                             hrefFindDest = SoapUtils.getQualifiedAttributeNode(messageFactory, idParteDest, "tipo", SPCoopCostanti.NAMESPACE_EGOV);
  1316.                         }else{
  1317.                             hrefFindDest = SoapUtils.getAttributeNode(messageFactory, idParteDest, "tipo");
  1318.                         }
  1319.                         String itValue = hrefFindDest.getNodeValue();
  1320.                         if(itValue!=null) {
  1321.                             try {
  1322.                                 errore.setTipoDestinatario(this.traduttore.toRegistryOrganizationType(itValue));
  1323.                             }catch(Exception e) {
  1324.                                 errore.setTipoDestinatario(itValue); // senza traduzione
  1325.                             }
  1326.                         }
  1327.                     }catch(Exception e){
  1328.                         // ignore
  1329.                     }
  1330.                     try{
  1331.                         List<Node> headerDest = SoapUtils.getNotEmptyChildNodes(messageFactory, destinatario);
  1332.                         Node idParteDest = headerDest.get(0);
  1333.                         Node hrefFindDest = null;
  1334.                         if(this.readQualifiedAttribute){
  1335.                             hrefFindDest = SoapUtils.getQualifiedAttributeNode(messageFactory, idParteDest, "indirizzoTelematico", SPCoopCostanti.NAMESPACE_EGOV);
  1336.                         }else{
  1337.                             hrefFindDest = SoapUtils.getAttributeNode(messageFactory, idParteDest, "indirizzoTelematico");
  1338.                         }
  1339.                         String itValue = hrefFindDest.getNodeValue();
  1340.                         errore.setIndirizzoDestinatario(itValue);
  1341.                     }catch(Exception e){
  1342.                         // ignore
  1343.                     }
  1344.                 }
  1345.                 
  1346.                 // Servizio
  1347.                 if(servizio!=null){
  1348.                     try{
  1349.                         errore.setServizio(SoapUtils.getNotEmptyChildNodes(messageFactory, servizio).get(0).getNodeValue());
  1350.                     }catch(Exception e){
  1351.                         // ignore
  1352.                     }
  1353.                     try{
  1354.                         Node hrefFind = null;
  1355.                         if(this.readQualifiedAttribute){
  1356.                             hrefFind = SoapUtils.getQualifiedAttributeNode(messageFactory, servizio, "tipo", SPCoopCostanti.NAMESPACE_EGOV);
  1357.                         }else{
  1358.                             hrefFind = SoapUtils.getAttributeNode(messageFactory, servizio, "tipo");
  1359.                         }
  1360.                         String value = hrefFind.getNodeValue();
  1361.                         if(value!=null) {
  1362.                             try {
  1363.                                 errore.setTipoServizio(this.traduttore.toRegistryServiceType(value));
  1364.                             }catch(Exception e) {
  1365.                                 errore.setTipoServizio(value); // senza traduzione
  1366.                             }
  1367.                         }
  1368.                     }catch(Exception e){
  1369.                         // ignore
  1370.                     }
  1371.                 }
  1372.                 
  1373.                 // Azione
  1374.                 if(azione!=null){
  1375.                     try{
  1376.                         errore.setAzione(SoapUtils.getNotEmptyChildNodes(messageFactory, azione).get(0).getNodeValue());
  1377.                     }catch(Exception e){
  1378.                         // ignore
  1379.                     }
  1380.                 }
  1381.                 
  1382.                 // ProfiloDiCollaborazione
  1383.                 if(profiloCollaborazione!=null){
  1384.                     try{
  1385.                         String profilovalue = SoapUtils.getNotEmptyChildNodes(messageFactory, profiloCollaborazione).get(0).getNodeValue();
  1386.                         errore.setProfiloDiCollaborazione(toProfilo(profilovalue), profilovalue);
  1387.                     }catch(Exception e){
  1388.                         // ignore
  1389.                     }
  1390.                     try{
  1391.                         Node hrefFind = null;
  1392.                         if(this.readQualifiedAttribute){
  1393.                             hrefFind = SoapUtils.getQualifiedAttributeNode(messageFactory, profiloCollaborazione, "tipo", SPCoopCostanti.NAMESPACE_EGOV);
  1394.                         }else{
  1395.                             hrefFind = SoapUtils.getAttributeNode(messageFactory, profiloCollaborazione, "tipo");
  1396.                         }
  1397.                         String value = hrefFind.getNodeValue();
  1398.                         if(value!=null) {
  1399.                             try {
  1400.                                 errore.setTipoServizioCorrelato(this.traduttore.toRegistryServiceType(value));
  1401.                             }catch(Exception e) {
  1402.                                 errore.setTipoServizioCorrelato(value); // senza traduzione
  1403.                             }
  1404.                         }
  1405.                     }catch(Exception e){
  1406.                         // ignore
  1407.                     }
  1408.                     try{
  1409.                         Node hrefFind = null;
  1410.                         if(this.readQualifiedAttribute){
  1411.                             hrefFind = SoapUtils.getQualifiedAttributeNode(messageFactory, profiloCollaborazione, "servizioCorrelato", SPCoopCostanti.NAMESPACE_EGOV);
  1412.                         }else{
  1413.                             hrefFind = SoapUtils.getAttributeNode(messageFactory, profiloCollaborazione, "servizioCorrelato");
  1414.                         }
  1415.                         errore.setServizioCorrelato(hrefFind.getNodeValue());
  1416.                     }catch(Exception e){
  1417.                         // ignore
  1418.                     }
  1419.                 }
  1420.                 
  1421.                 // Collaborazione
  1422.                 if(collaborazione!=null){
  1423.                     try{
  1424.                         errore.setCollaborazione(SoapUtils.getNotEmptyChildNodes(messageFactory, collaborazione).get(0).getNodeValue());
  1425.                     }catch(Exception e){
  1426.                         // ignore
  1427.                     }
  1428.                 }
  1429.                 
  1430.                 // Messaggio
  1431.                 if(messaggio!=null){
  1432.                     try{
  1433.                         List<Node> contenutoMsg = SoapUtils.getNotEmptyChildNodes(messageFactory, messaggio);
  1434.                         for(int j =0; j<contenutoMsg.size();j++){
  1435.                             Node childMsg = contenutoMsg.get(j);
  1436.                             //if((childMsg.getNodeName().equals(xmlns+"RiferimentoMessaggio"))){
  1437.                             if(SoapUtils.matchLocalName(messageFactory, childMsg, "RiferimentoMessaggio", xmlns, SPCoopCostanti.NAMESPACE_EGOV)){
  1438.                                 try{
  1439.                                     errore.setRiferimentoMessaggio(SoapUtils.getNotEmptyChildNodes(messageFactory, childMsg).get(0).getNodeValue());
  1440.                                 }catch(Exception e){
  1441.                                     // ignore
  1442.                                 }
  1443.                             }
  1444.                             //else if((childMsg.getNodeName().equals(xmlns+"Scadenza"))){
  1445.                             else if(SoapUtils.matchLocalName(messageFactory, childMsg, "Scadenza", xmlns, SPCoopCostanti.NAMESPACE_EGOV)){
  1446.                                 try{
  1447.                                     String scadenza = SoapUtils.getNotEmptyChildNodes(messageFactory, childMsg).get(0).getNodeValue();
  1448.                                     Date scadenzaDate = validazioneData(scadenza);
  1449.                                     errore.setScadenza(scadenzaDate);
  1450.                                 }catch(Exception e){
  1451.                                     // ignore
  1452.                                 }
  1453.                             }
  1454.                             //else if((childMsg.getNodeName().equals(xmlns+"OraRegistrazione"))){
  1455.                             else if(SoapUtils.matchLocalName(messageFactory, childMsg, "OraRegistrazione", xmlns, SPCoopCostanti.NAMESPACE_EGOV)){
  1456.                                 try{
  1457.                                     String oraRegistrazione = SoapUtils.getNotEmptyChildNodes(messageFactory, childMsg).get(0).getNodeValue();
  1458.                                     Date oraDate = validazioneData(oraRegistrazione);
  1459.                                     errore.setOraRegistrazione(oraDate);
  1460.                                 }catch(Exception e){
  1461.                                     // ignore
  1462.                                 }
  1463.                                 try{
  1464.                                     Node hrefFind = null;
  1465.                                     if(this.readQualifiedAttribute){
  1466.                                         hrefFind = SoapUtils.getQualifiedAttributeNode(messageFactory, childMsg, "tempo", SPCoopCostanti.NAMESPACE_EGOV);
  1467.                                     }else{
  1468.                                         hrefFind = SoapUtils.getAttributeNode(messageFactory, childMsg, "tempo");
  1469.                                     }
  1470.                                     String tipoOraRegistrazioneValue = hrefFind.getNodeValue();
  1471.                                     errore.setTipoOraRegistrazione(toTipoOra(tipoOraRegistrazioneValue), tipoOraRegistrazioneValue);
  1472.                                 }catch(Exception e){
  1473.                                     // ignore
  1474.                                 }
  1475.                             }
  1476.                         }
  1477.                     }catch(Exception e){
  1478.                         // ignore
  1479.                     }
  1480.                 }
  1481.                 
  1482.                 // Profilo Trasmissione
  1483.                 if(profiloTrasmissione!=null){
  1484.                     try{
  1485.                         Node hrefFind = null;
  1486.                         if(this.readQualifiedAttribute){
  1487.                             hrefFind = SoapUtils.getQualifiedAttributeNode(messageFactory, profiloTrasmissione, "confermaRicezione", SPCoopCostanti.NAMESPACE_EGOV);
  1488.                         }else{
  1489.                             hrefFind = SoapUtils.getAttributeNode(messageFactory, profiloTrasmissione, "confermaRicezione");
  1490.                         }
  1491.                         if(hrefFind.getNodeValue().equals("true"))
  1492.                             errore.setConfermaRicezione(true);
  1493.                         else
  1494.                             errore.setConfermaRicezione(false);
  1495.                     }catch(Exception e){
  1496.                         // ignore
  1497.                     }
  1498.                     try{
  1499.                         Node hrefFind = null;
  1500.                         if(this.readQualifiedAttribute){
  1501.                             hrefFind = SoapUtils.getQualifiedAttributeNode(messageFactory, profiloTrasmissione, "inoltro", SPCoopCostanti.NAMESPACE_EGOV);
  1502.                         }else{
  1503.                             hrefFind = SoapUtils.getAttributeNode(messageFactory, profiloTrasmissione, "inoltro");
  1504.                         }
  1505.                         String inoltro = hrefFind.getNodeValue();
  1506.                         errore.setInoltro(toInoltro(inoltro), inoltro);
  1507.                     }catch(Exception e){
  1508.                         // ignore
  1509.                     }
  1510.                 }
  1511.                 
  1512.                 // Sequenza
  1513.                 if(sequenza!=null){
  1514.                     try{
  1515.                         Node hrefFind = null;
  1516.                         if(this.readQualifiedAttribute){
  1517.                             hrefFind = SoapUtils.getQualifiedAttributeNode(messageFactory, sequenza, "numeroProgressivo", SPCoopCostanti.NAMESPACE_EGOV);
  1518.                         }else{
  1519.                             hrefFind = SoapUtils.getAttributeNode(messageFactory, sequenza, "numeroProgressivo");
  1520.                         }
  1521.                         Long test = Long.valueOf(hrefFind.getNodeValue());
  1522.                         errore.setSequenza(test.longValue());
  1523.                     }catch(Exception e){
  1524.                         // ignore
  1525.                     }
  1526.                 }
  1527.                 
  1528.                 this.bustaErroreHeaderIntestazione = errore;
  1529.                 throw new Exception("Header eGov senza alcuni elementi principali: presenza mittente["+(mittente!=null)+"] destinatario["+(destinatario!=null)+"] messaggio["+(messaggio!=null)+"] eccezioni-riscontrate: ["+errore.toStringListaEccezioni(this.getProtocolFactory())+"]"); 
  1530.             }
  1531.             
  1532.             return new SPCoopBustaRawContent(headerElementEGov);
  1533.             
  1534.         }catch(StrutturaBustaException e){
  1535.             throw e;
  1536.         }catch(Exception e){
  1537.             throw new ProtocolException("Lettura non riuscita: "+e.getMessage(),e);
  1538.         }
  1539.     }


  1542.     /**
  1543.      * Controlla che esista una busta SPCoop nell'header
  1544.      * 
  1545.      * @return true se l'header esiste, false altrimenti
  1546.      */
  1547.     public boolean existsHeaderEGov(OpenSPCoop2SoapMessage msg){
  1548.         this.msg = msg;
  1549.         try{
  1550.             if(this.headerEGov!=null){
  1551.                 return true;
  1552.             }else{
  1553.                 if(msg==null){
  1554.                     return false;
  1555.                 }
  1556.                 if(this.headerSOAP==null)
  1557.                     this.headerSOAP = this.msg.getSOAPHeader();
  1558.                 if(this.headerSOAP == null){
  1559.                     return false;
  1560.                 }
  1561.                 
  1562.                 // cerco la busta per l'actor
  1563.                 java.util.Iterator<?> it = this.headerSOAP.examineAllHeaderElements();
  1564.                 SOAPHeaderElement headerElementEGov = null;
  1565.                 while( it.hasNext()  ){

  1567.                     // Test Header Element
  1568.                     SOAPHeaderElement headerElement = (SOAPHeaderElement) it.next();

  1570.                     //Controllo Actor
  1571.                     if( SPCoopCostanti.ACTOR_EGOV.equals(headerElement.getActor()) == false  ){
  1572.                         continue;
  1573.                     }
  1574.                     headerElementEGov = headerElement;
  1575.                 }
  1576.                 
  1577.                 if(headerElementEGov==null){
  1578.                     // cerco la busta per il namespace
  1579.                     it = this.headerSOAP.examineAllHeaderElements();
  1580.                     while( it.hasNext()  ){

  1582.                         // Test Header Element
  1583.                         SOAPHeaderElement headerElement = (SOAPHeaderElement) it.next();

  1585.                         //Controllo Namespace
  1586.                         if( SPCoopCostanti.NAMESPACE_EGOV.equals(headerElement.getNamespaceURI()) == false  ){
  1587.                             continue;
  1588.                         }
  1589.                         headerElementEGov = headerElement;
  1590.                     }
  1591.                 }
  1592.                 
  1593.                 return headerElementEGov!=null;
  1594.             }
  1595.             

  1597.         }catch(Exception e){
  1598.             this.log.error("existsHeaderEGov error: "+e.getMessage(), e);
  1599.             return false;
  1600.         }
  1601.     }
  1602.     
  1603.     /**
  1604.      * Controlla che esista più di una busta SPCoop nell'header
  1605.      * 
  1606.      * @return true se l'header esiste, false altrimenti
  1607.      */
  1608.     public boolean existsMoreHeaderEGov(){
  1609.         try{
  1610.             if(this.headerSOAP==null)
  1611.                 this.headerSOAP = this.msg.getSOAPHeader();
  1612.             if(this.headerSOAP == null){
  1613.                 return false;
  1614.             }
  1615.                 
  1616.             boolean headerGiaTrovato = false;
  1617.             
  1618.             // cerco la busta per l'actor
  1619.             java.util.Iterator<?> it = this.headerSOAP.examineAllHeaderElements();
  1620.             while( it.hasNext()  ){
  1621.                 
  1622.                 // Test Header Element
  1623.                 SOAPHeaderElement headerElement = (SOAPHeaderElement) it.next();

  1625.                 //Controllo Actor
  1626.                 if( SPCoopCostanti.ACTOR_EGOV.equals(headerElement.getActor()) == false  ){
  1627.                     continue;
  1628.                 }
  1629.                 if(headerGiaTrovato)
  1630.                     return true;
  1631.                 else
  1632.                     headerGiaTrovato = true;
  1633.             }
  1634.                 
  1635.             if(headerGiaTrovato==false){
  1636.                 // cerco la busta per il namespace
  1637.                 it = this.headerSOAP.examineAllHeaderElements();
  1638.                 while( it.hasNext()  ){

  1640.                     // Test Header Element
  1641.                     SOAPHeaderElement headerElement = (SOAPHeaderElement) it.next();

  1643.                     //Controllo Namespace
  1644.                     if( SPCoopCostanti.NAMESPACE_EGOV.equals(headerElement.getNamespaceURI()) == false  ){
  1645.                         continue;
  1646.                     }
  1647.                     
  1648.                     if(headerGiaTrovato)
  1649.                         return true;
  1650.                     else
  1651.                         headerGiaTrovato = true;
  1652.                 }
  1653.                 
  1654.             }
  1655.             
  1656.             return false;
  1657.             

  1659.         }catch(Exception e){
  1660.             this.log.error("existsMoreHeaderEGov error: "+e.getMessage());
  1661.             return false;
  1662.         }
  1663.     }


  1666.     /**
  1667.      * Metodo che ritorna il prefissso eGov
  1668.      * 
  1669.      * @return Prefisso
  1670.      * 
  1671.      */
  1672.     public String getPrefix(){

  1674.         // Prefix eGov
  1675.         String xmlns = this.headerEGov.getElement().getPrefix();
  1676.         if(xmlns == null){ 
  1677.             xmlns = "";
  1678.         }
  1679.         if(!xmlns.equals(""))
  1680.             xmlns = xmlns + ":";
  1681.         return xmlns;
  1682.     }



  1686.     /**
  1687.      * Metodo che si occupa di validare l'elemento 'Mittente' <var>child</var> secondo specifica eGov.
  1688.      * Il metodo, oltre ad effettuare la validazione, si occupa anche di leggerne il contenuto e 
  1689.      * di impostarlo all'interno dell'oggetto <var>busta</var>.
  1690.      * Mano mano che sono incontrati errori di validazione, viene creato un oggetto :
  1691.      *    {@link Eccezione}, e viene inserito in errors.
  1692.      *
  1693.      * @param child nodo su cui effettuare la validazione.
  1694.      * @throws ProtocolException 
  1695.      * 
  1696.      */
  1697.     private void validazioneMittente(OpenSPCoop2MessageFactory messageFactory, Node child,String prefix) throws ProtocolException{

  1699.         //log.info("Validazione Mittente...");

  1701.         List<Node> headerMittente = SoapUtils.getNotEmptyChildNodes(messageFactory, child);
  1702.         Node idParte = headerMittente.get(0);
  1703.         //log.info("esamino ["+idParte.getNodeName()+"]"); 
  1704.         List<Node> valueIDParte = SoapUtils.getNotEmptyChildNodes(messageFactory, idParte);
  1705.         String value =  valueIDParte.get(0).getNodeValue();
  1706.         //log.info("Value identificativo parte Mittente ["+value+"]");
  1707.         Node hrefFind = null;
  1708.         if(this.readQualifiedAttribute){
  1709.             hrefFind = SoapUtils.getQualifiedAttributeNode(messageFactory, idParte, "tipo", SPCoopCostanti.NAMESPACE_EGOV);
  1710.         }else{
  1711.             hrefFind = SoapUtils.getAttributeNode(messageFactory, idParte, "tipo");
  1712.         }
  1713.         String tipo = hrefFind.getNodeValue();
  1714.         //log.info("Tipo identificativo parte Mittente ["+tipo+"]");
  1715.         
  1716.         // Controllo tipo
  1717.         try {
  1718.             this.busta.setTipoMittente(this.traduttore.toRegistryOrganizationType(tipo));
  1719.         }catch(Exception e) {
  1720.             this.busta.setTipoMittente(tipo); // senza traduzione
  1721.         
  1722.             this.log.warn(e.getMessage(),e);
  1723.             Eccezione ecc = new Eccezione();
  1724.             ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  1725.             ecc.setCodiceEccezione(CodiceErroreCooperazione.TIPO_MITTENTE_NON_VALIDO);
  1726.             ecc.setRilevanza(LivelloRilevanza.ERROR);
  1727.             ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_MITTENTE_SCONOSCIUTO_POSIZIONE_IDENTIFICATIVO_PARTE_TIPO.toString());
  1728.             this.erroriValidazione.add(ecc);
  1729.         }       
  1730.         this.busta.setMittente(value);
  1731.         String indTelematico = null;
  1732.         // indirizzo Telematico
  1733.         try{
  1734.             Node hrefFindT = null;
  1735.             if(this.readQualifiedAttribute){
  1736.                 hrefFindT = SoapUtils.getQualifiedAttributeNode(messageFactory, idParte, "indirizzoTelematico", SPCoopCostanti.NAMESPACE_EGOV);
  1737.             }else{
  1738.                 hrefFindT = SoapUtils.getAttributeNode(messageFactory, idParte, "indirizzoTelematico");
  1739.             }
  1740.             if(hrefFindT != null)
  1741.                 indTelematico = hrefFindT.getNodeValue();
  1742.             //log.info("IndirizzoTelematicoMittente ["+indTelematico+"]");
  1743.         } catch(Exception e) {
  1744.             Eccezione ecc = new Eccezione();
  1745.             ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  1746.             ecc.setCodiceEccezione(CodiceErroreCooperazione.INDIRIZZO_MITTENTE_NON_PRESENTE );
  1747.             ecc.setRilevanza(LivelloRilevanza.ERROR);
  1748.             ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_MITTENTE_SCONOSCIUTO_POSIZIONE_IDENTIFICATIVO_PARTE_IND_TELEMATICO.toString());
  1749.             this.erroriValidazione.add(ecc);
  1750.         }
  1751.         if(indTelematico != null && (indTelematico.equals("")==false)){ 
  1752.             URL urlCheck = null;
  1753.             try{    
  1754.                 urlCheck = new URL( indTelematico );
  1755.                 this.busta.setIndirizzoMittente(urlCheck.toString());
  1756.             } catch(Exception e) {
  1757.                 this.busta.setIndirizzoMittente(indTelematico); // comunque lo imposto!
  1758.                 Eccezione ecc = new Eccezione();
  1759.                 ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  1760.                 ecc.setCodiceEccezione(CodiceErroreCooperazione.INDIRIZZO_MITTENTE_NON_VALIDO);
  1761.                 ecc.setRilevanza(LivelloRilevanza.ERROR);
  1762.                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_MITTENTE_SCONOSCIUTO_POSIZIONE_IDENTIFICATIVO_PARTE_IND_TELEMATICO.toString());
  1763.                 this.erroriValidazione.add(ecc);
  1764.             }
  1765.         }   
  1766.         

  1768.     }

  1770.     /**
  1771.      * Metodo che si occupa di validare l'elemento 'Destinatario' <var>child</var> secondo specifica eGov.
  1772.      * Il metodo, oltre ad effettuare la validazione, si occupa anche di leggerne il contenuto e 
  1773.      * di impostarlo all'interno dell'oggetto <var>busta</var>.
  1774.      * Mano mano che sono incontrati errori di validazione, viene creato un oggetto 
  1775.      *    {@link Eccezione}, e viene inserito in errors.
  1776.      *
  1777.      * @param child nodo su cui effettuare la validazione
  1778.      * @throws ProtocolException 
  1779.      * 
  1780.      */
  1781.     private void validazioneDestinatario(OpenSPCoop2MessageFactory messageFactory, Node child,String prefix) throws ProtocolException{

  1783.         //log.info("Validazione Destinatario...");

  1785.         List<Node> headerDestinatario = SoapUtils.getNotEmptyChildNodes(messageFactory, child);
  1786.         Node idParte = headerDestinatario.get(0);
  1787.         //log.info("esamino ["+idParte.getNodeName()+"]"); 
  1788.         List<Node> valueIDParte = SoapUtils.getNotEmptyChildNodes(messageFactory, idParte);
  1789.         String value =  valueIDParte.get(0).getNodeValue();
  1790.         //log.info("Value identificativo parte Destinatario ["+value+"]");
  1791.         Node hrefFind = null;
  1792.         if(this.readQualifiedAttribute){
  1793.             hrefFind = SoapUtils.getQualifiedAttributeNode(messageFactory, idParte, "tipo", SPCoopCostanti.NAMESPACE_EGOV);
  1794.         }else{
  1795.             hrefFind = SoapUtils.getAttributeNode(messageFactory, idParte, "tipo");
  1796.         }
  1797.         String tipo = hrefFind.getNodeValue();
  1798.         //log.info("Tipo identificativo parte Destinatario ["+tipo+"]");
  1799.         
  1800.         // Controllo tipo
  1801.         try {
  1802.             this.busta.setTipoDestinatario(this.traduttore.toRegistryOrganizationType(tipo));
  1803.         }catch(Exception e) {
  1804.             this.busta.setTipoDestinatario(tipo); // senza traduzione
  1805.             
  1806.             this.log.warn(e.getMessage(),e);
  1807.             Eccezione ecc = new Eccezione();
  1808.             ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  1809.             ecc.setCodiceEccezione(CodiceErroreCooperazione.TIPO_DESTINATARIO_SCONOSCIUTO );
  1810.             ecc.setRilevanza(LivelloRilevanza.ERROR);
  1811.             ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_DESTINATARIO_SCONOSCIUTO_POSIZIONE_IDENTIFICATIVO_PARTE_TIPO.toString());
  1812.             this.erroriValidazione.add(ecc);
  1813.         }
  1814.         this.busta.setDestinatario(value);

  1816.         String indTelematico = null;
  1817.         // indirizzo Telematico
  1818.         try{
  1819.             Node hrefFindT = null;
  1820.             if(this.readQualifiedAttribute){
  1821.                 hrefFindT = SoapUtils.getQualifiedAttributeNode(messageFactory, idParte, "indirizzoTelematico", SPCoopCostanti.NAMESPACE_EGOV);
  1822.             }else{
  1823.                 hrefFindT = SoapUtils.getAttributeNode(messageFactory, idParte, "indirizzoTelematico");
  1824.             }
  1825.             if(hrefFindT != null)
  1826.                 indTelematico = hrefFindT.getNodeValue();
  1827.             //log.info("IndirizzoTelematicoMittente ["+indTelematico+"]");
  1828.         } catch(Exception e) {
  1829.             Eccezione ecc = new Eccezione();
  1830.             ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  1831.             ecc.setCodiceEccezione(CodiceErroreCooperazione.INDIRIZZO_DESTINATARIO_NON_PRESENTE );
  1832.             ecc.setRilevanza(LivelloRilevanza.ERROR);
  1833.             ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_DESTINATARIO_SCONOSCIUTO_POSIZIONE_IDENTIFICATIVO_PARTE_IND_TELEMATICO.toString());
  1834.             this.erroriValidazione.add(ecc);
  1835.         }
  1836.         if(indTelematico != null && (indTelematico.equals("")==false)){ 
  1837.             URL urlcheck = null;
  1838.             try{    
  1839.                 urlcheck = new URL( indTelematico );
  1840.                 this.busta.setIndirizzoDestinatario(urlcheck.toString());
  1841.             } catch(Exception e) {
  1842.                 this.busta.setIndirizzoDestinatario(indTelematico); // comunque lo imposto!
  1843.                 Eccezione ecc = new Eccezione();
  1844.                 ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  1845.                 ecc.setCodiceEccezione(CodiceErroreCooperazione.INDIRIZZO_DESTINATARIO_NON_VALIDO );
  1846.                 ecc.setRilevanza(LivelloRilevanza.ERROR);
  1847.                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_DESTINATARIO_SCONOSCIUTO_POSIZIONE_IDENTIFICATIVO_PARTE_IND_TELEMATICO.toString());
  1848.                 this.erroriValidazione.add(ecc);
  1849.             }
  1850.         }   
  1851.         


  1854.     }


  1857.     /**
  1858.      * Metodo che si occupa di validare l'elemento 'ProfiloCollaborazione' <var>child</var> secondo specifica eGov.
  1859.      * Il metodo, oltre ad effettuare la validazione, si occupa anche di leggerne il contenuto e 
  1860.      * di impostarlo all'interno dell'oggetto <var>busta</var>.
  1861.      * Mano mano che sono incontrati errori di validazione, viene creato un oggetto 
  1862.      *    {@link Eccezione}, e viene inserito in errors.
  1863.      *
  1864.      * @param child nodo su cui effettuare la validazione
  1865.      * @throws ProtocolException 
  1866.      * 
  1867.      */
  1868.     private void validazioneProfiloCollaborazione(OpenSPCoop2MessageFactory messageFactory, Node child,String prefix) throws ProtocolException{

  1870.         //log.info("Validazione Profilo di Collaborazione...");
  1871.         String profilo = null;

  1873.         List<Node> valueProfiloDiCollaborazione = SoapUtils.getNotEmptyChildNodes(messageFactory, child);
  1874.         if( valueProfiloDiCollaborazione.size() == 0 || valueProfiloDiCollaborazione.size() > 1  ){ 
  1875.             Eccezione ecc = new Eccezione();
  1876.             ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  1877.             ecc.setCodiceEccezione(CodiceErroreCooperazione.PROFILO_COLLABORAZIONE_NON_VALIDO);
  1878.             ecc.setRilevanza(LivelloRilevanza.ERROR);
  1879.             ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_PROFILO_COLLABORAZIONE_SCONOSCIUTO_POSIZIONE.toString());
  1880.             this.erroriValidazione.add(ecc);
  1881.         }else {
  1882.             try{
  1883.                 profilo = valueProfiloDiCollaborazione.get(0).getNodeValue();
  1884.                 //log.info("Value Profilo di Collaborazione ["+valueProfiloDiCollaborazione.item(0).getNodeValue()+"]");
  1885.                 if( (profilo.equals(SPCoopCostanti.PROFILO_COLLABORAZIONE_ONEWAY) == false) && 
  1886.                         (profilo.equals(SPCoopCostanti.PROFILO_COLLABORAZIONE_SINCRONO) == false) && 
  1887.                         (profilo.equals(SPCoopCostanti.PROFILO_COLLABORAZIONE_ASINCRONO_SIMMETRICO) == false) && 
  1888.                         (profilo.equals(SPCoopCostanti.PROFILO_COLLABORAZIONE_ASINCRONO_ASIMMETRICO) == false)){ 
  1889.                     Eccezione ecc = new Eccezione();
  1890.                     ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  1891.                     ecc.setCodiceEccezione(CodiceErroreCooperazione.PROFILO_COLLABORAZIONE_SCONOSCIUTO);
  1892.                     ecc.setRilevanza(LivelloRilevanza.ERROR);
  1893.                     ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_PROFILO_COLLABORAZIONE_SCONOSCIUTO_POSIZIONE.toString());
  1894.                     this.erroriValidazione.add(ecc);
  1895.                 }
  1896.                 this.busta.setProfiloDiCollaborazione(toProfilo(profilo), profilo);
  1897.             } catch(Exception e) {
  1898.                 Eccezione ecc = new Eccezione();
  1899.                 ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  1900.                 ecc.setCodiceEccezione(CodiceErroreCooperazione.PROFILO_COLLABORAZIONE_NON_VALIDO);
  1901.                 ecc.setRilevanza(LivelloRilevanza.ERROR);
  1902.                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_PROFILO_COLLABORAZIONE_SCONOSCIUTO_POSIZIONE.toString());
  1903.                 this.erroriValidazione.add(ecc); 
  1904.             }       
  1905.         }

  1907.         // Controllo servizioCorrelato e Tipo
  1908.         String tipo = null;
  1909.         try{
  1910.             Node hrefFind = null;
  1911.             if(this.readQualifiedAttribute){
  1912.                 hrefFind = SoapUtils.getQualifiedAttributeNode(messageFactory, child, "tipo", SPCoopCostanti.NAMESPACE_EGOV);
  1913.             }else{
  1914.                 hrefFind = SoapUtils.getAttributeNode(messageFactory, child, "tipo");
  1915.             }
  1916.             if(hrefFind != null)
  1917.                 tipo = hrefFind.getNodeValue();
  1918.             //log.info("Tipo Servizio Correlato ["+tipo+"]");
  1919.         } catch(Exception e) {
  1920.             Eccezione ecc = new Eccezione();
  1921.             ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  1922.             ecc.setCodiceEccezione(CodiceErroreCooperazione.TIPO_SERVIZIO_CORRELATO_NON_VALIDO );
  1923.             ecc.setRilevanza(LivelloRilevanza.ERROR);
  1924.             ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_PROFILO_COLLABORAZIONE_SCONOSCIUTO_POSIZIONE_TIPO_SERVIZIO_CORRELATO.toString());
  1925.             this.erroriValidazione.add(ecc);
  1926.         }
  1927.         boolean tipoServizioCorrelatoValido = true;
  1928.         if(tipo != null){ 
  1929.             // Controllo tipo
  1930.             try {
  1931.                 this.busta.setTipoServizioCorrelato(this.traduttore.toRegistryServiceType(tipo));
  1932.             }catch(Exception e) {
  1933.                 tipoServizioCorrelatoValido = false;
  1934.                 this.busta.setTipoServizioCorrelato(tipo); // senza traduzione
  1935.                 
  1936.                 this.log.warn(e.getMessage(),e);
  1937.                 Eccezione ecc = new Eccezione();
  1938.                 ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  1939.                 ecc.setCodiceEccezione(CodiceErroreCooperazione.TIPO_SERVIZIO_CORRELATO_SCONOSCIUTO );
  1940.                 ecc.setRilevanza(LivelloRilevanza.ERROR);
  1941.                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_PROFILO_COLLABORAZIONE_SCONOSCIUTO_POSIZIONE_TIPO_SERVIZIO_CORRELATO.toString());
  1942.                 this.erroriValidazione.add(ecc);
  1943.             }
  1944.             
  1945.             /* OLD CODICE           
  1946.             if(!tipo.equals(Costanti.SERVIZIO_CORRELATO_SPC) &&
  1947.                     !tipo.equals(Costanti.SERVIZIO_CORRELATO_TEST) &&
  1948.                     !tipo.equals(Costanti.SERVIZIO_CORRELATO_URL) &&
  1949.                     !tipo.equals(Costanti.SERVIZIO_CORRELATO_WSDL) &&
  1950.                     !tipo.equals(Costanti.SERVIZIO_CORRELATO_LDAP) &&
  1951.                     !tipo.equals(Costanti.SERVIZIO_CORRELATO_UDDI) &&
  1952.                     !tipo.equals(Costanti.SERVIZIO_CORRELATO_XML_REGISTRY) ){
  1953.                 Eccezione ecc = new Eccezione();
  1954.                 ecc.setContestoCodifica(Costanti.CONTESTO_CODIFICA_ECCEZIONE_VALIDAZIONE);
  1955.                 ecc.setCodiceEccezione(Costanti.ECCEZIONE_PROFILO_COLLABORAZIONE_SCONOSCIUTO );
  1956.                 ecc.setRilevanza(LivelloRilevanza.GRAVE);
  1957.                 ecc.setDescrizione(Costanti.ECCEZIONE_PROFILO_COLLABORAZIONE_SCONOSCIUTO_POSIZIONE_TIPO_SERVIZIO_CORRELATO);
  1958.                 this.erroriValidazione.add(ecc);
  1959.             }   
  1960.             */
  1961.         }


  1964.         String servizioCorrelato = null;
  1965.         try{
  1966.             Node hrefFind = null;
  1967.             if(this.readQualifiedAttribute){
  1968.                 hrefFind = SoapUtils.getQualifiedAttributeNode(messageFactory, child, "servizioCorrelato", SPCoopCostanti.NAMESPACE_EGOV);
  1969.             }else{
  1970.                 hrefFind = SoapUtils.getAttributeNode(messageFactory, child, "servizioCorrelato");
  1971.             }
  1972.             if(hrefFind != null)
  1973.                 servizioCorrelato = hrefFind.getNodeValue();
  1974.             //log.info("Servizio Correlato ["+servizioCorrelato+"]");
  1975.         } catch(Exception e) {
  1976.             Eccezione ecc = new Eccezione();
  1977.             ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  1978.             ecc.setCodiceEccezione(CodiceErroreCooperazione.SERVIZIO_CORRELATO_NON_VALIDO );
  1979.             ecc.setRilevanza(LivelloRilevanza.ERROR);
  1980.             ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_PROFILO_COLLABORAZIONE_SCONOSCIUTO_POSIZIONE_SERVIZIO_CORRELATO.toString());
  1981.             this.erroriValidazione.add(ecc);
  1982.         }
  1983.         this.busta.setServizioCorrelato(servizioCorrelato);


  1986.         // MessaggioSingoloOneWay e Sincrono
  1987.         if (   servizioCorrelato != null  && 
  1988.                 (  SPCoopCostanti.PROFILO_COLLABORAZIONE_ONEWAY.equals(profilo) == true || 
  1989.                         SPCoopCostanti.PROFILO_COLLABORAZIONE_SINCRONO.equals(profilo) == true    )) {
  1990.             Eccezione ecc = new Eccezione();
  1991.             ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  1992.             ecc.setCodiceEccezione(CodiceErroreCooperazione.SERVIZIO_CORRELATO_NON_VALIDO);
  1993.             ecc.setRilevanza(LivelloRilevanza.ERROR);
  1994.             ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_PROFILO_COLLABORAZIONE_SCONOSCIUTO_POSIZIONE_SERVIZIO_CORRELATO.toString());
  1995.             this.erroriValidazione.add(ecc);
  1996.         }
  1997.         if ( tipoServizioCorrelatoValido && (tipo!=null) &&  
  1998.                 (  SPCoopCostanti.PROFILO_COLLABORAZIONE_ONEWAY.equals(profilo) == true || 
  1999.                         SPCoopCostanti.PROFILO_COLLABORAZIONE_SINCRONO.equals(profilo) == true    )) {
  2000.             Eccezione ecc = new Eccezione();
  2001.             ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  2002.             ecc.setCodiceEccezione(CodiceErroreCooperazione.TIPO_SERVIZIO_CORRELATO_NON_VALIDO);
  2003.             ecc.setRilevanza(LivelloRilevanza.ERROR);
  2004.             ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_PROFILO_COLLABORAZIONE_SCONOSCIUTO_POSIZIONE_TIPO_SERVIZIO_CORRELATO.toString());
  2005.             this.erroriValidazione.add(ecc);
  2006.         }

  2008.     }

  2010.     /**
  2011.      * Metodo che si occupa di validare l'elemento 'Collaborazione' <var>child</var> secondo specifica eGov.
  2012.      * <p>
  2013.      * Il metodo, oltre ad effettuare la validazione, si occupa anche di leggerne il contenuto e 
  2014.      * di impostarlo all'interno dell'oggetto <var>busta</var>.
  2015.      * Mano mano che sono incontrati errori di validazione, viene creato un oggetto 
  2016.      *    {@link Eccezione}, e viene inserito in errors.
  2017.      *
  2018.      * @param child nodo su cui effettuare la validazione
  2019.      * @throws ProtocolException 
  2020.      * 
  2021.      */
  2022.     private void validazioneCollaborazione(OpenSPCoop2MessageFactory messageFactory, Node child) throws ProtocolException{

  2024.         //log.info("Validazione Collaborazione...");
  2025.         if ( SoapUtils.getNotEmptyChildNodes(messageFactory, child).size() != 1 ){
  2026.             Eccezione ecc = new Eccezione();
  2027.             ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  2028.             ecc.setCodiceEccezione(CodiceErroreCooperazione.COLLABORAZIONE_NON_VALIDA);
  2029.             ecc.setRilevanza(LivelloRilevanza.ERROR);
  2030.             ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_COLLABORAZIONE_SCONOSCIUTA_POSIZIONE.toString());
  2031.             this.erroriValidazione.add(ecc);
  2032.             return;
  2033.         }
  2034.         String coll = null;
  2035.         try{
  2036.             coll = SoapUtils.getNotEmptyChildNodes(messageFactory, child).get(0).getNodeValue();
  2037.         } catch(Exception e) {
  2038.             Eccezione ecc = new Eccezione();
  2039.             ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  2040.             ecc.setCodiceEccezione(CodiceErroreCooperazione.COLLABORAZIONE_NON_VALORIZZATA);
  2041.             ecc.setRilevanza(LivelloRilevanza.ERROR);
  2042.             ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_COLLABORAZIONE_SCONOSCIUTA_POSIZIONE.toString());
  2043.             this.erroriValidazione.add(ecc);
  2044.         }
  2045.         //log.info("Collaborazione["+coll+"]");
  2046.         this.busta.setCollaborazione(coll);
  2047.     }

  2049.     /**
  2050.      * Metodo che si occupa di validare l'elemento 'Servizio' <var>child</var> secondo specifica eGov.
  2051.      * <p>
  2052.      * Il metodo, oltre ad effettuare la validazione, si occupa anche di leggerne il contenuto e 
  2053.      * di impostarlo all'interno dell'oggetto <var>busta</var>.
  2054.      * Mano mano che sono incontrati errori di validazione, viene creato un oggetto 
  2055.      *    {@link Eccezione}, e viene inserito in errors.
  2056.      *
  2057.      * @param child nodo su cui effettuare la validazione
  2058.      * @throws ProtocolException 
  2059.      * 
  2060.      */
  2061.     private void validazioneServizio(OpenSPCoop2MessageFactory messageFactory, Node child,String prefix) throws StrutturaBustaException, ProtocolException{

  2063.         //log.info("Validazione servizio...");
  2064.         if (SoapUtils.getNotEmptyChildNodes(messageFactory, child).size() != 1){
  2065.             Eccezione ecc = new Eccezione();
  2066.             ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  2067.             ecc.setCodiceEccezione(CodiceErroreCooperazione.SERVIZIO_NON_VALIDO);
  2068.             ecc.setRilevanza(LivelloRilevanza.ERROR);
  2069.             ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_SERVIZIO_SCONOSCIUTO_POSIZIONE.toString());
  2070.             this.erroriValidazione.add(ecc);
  2071.             return;
  2072.         }

  2074.         String serv = null;
  2075.         try{
  2076.             serv = SoapUtils.getNotEmptyChildNodes(messageFactory, child).get(0).getNodeValue();
  2077.         } catch(Exception e) {
  2078.             Eccezione ecc = new Eccezione();
  2079.             ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  2080.             ecc.setCodiceEccezione(CodiceErroreCooperazione.SERVIZIO_NON_VALORIZZATO);
  2081.             ecc.setRilevanza(LivelloRilevanza.ERROR);
  2082.             ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_SERVIZIO_SCONOSCIUTO_POSIZIONE.toString());
  2083.             this.erroriValidazione.add(ecc);
  2084.         }

  2086.         //log.info("Servizio["+serv+"]");
  2087.         this.busta.setServizio(serv);

  2089.         // Tipo
  2090.         String tipo = null;
  2091.         try{
  2092.             Node hrefFind = null;
  2093.             if(this.readQualifiedAttribute){
  2094.                 hrefFind = SoapUtils.getQualifiedAttributeNode(messageFactory, child, "tipo", SPCoopCostanti.NAMESPACE_EGOV);
  2095.             }else{
  2096.                 hrefFind = SoapUtils.getAttributeNode(messageFactory, child, "tipo");
  2097.             }
  2098.             if(hrefFind != null)
  2099.                 tipo = hrefFind.getNodeValue();
  2100.             //log.info("Servizio_tipo ["+tipo+"]");
  2101.             
  2102.             if (tipo == null){
  2103.                 if(this.spcoopProperties.isGenerazioneBustaErrore_strutturaMalformataHeaderProtocollo()==false){
  2104.                     throw new StrutturaBustaException("Header egov con elemento Servizio senza tipo","Servizio");
  2105.                 } else {
  2106.                     Eccezione ecc = new Eccezione();
  2107.                     ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  2108.                     ecc.setCodiceEccezione(CodiceErroreCooperazione.TIPO_SERVIZIO_NON_PRESENTE );
  2109.                     ecc.setRilevanza(LivelloRilevanza.ERROR);
  2110.                     ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_SERVIZIO_SCONOSCIUTO_POSIZIONE_TIPO.toString());
  2111.                     this.erroriValidazione.add(ecc);
  2112.                 }
  2113.             }else{
  2114.             
  2115.                 // Controllo tipo
  2116.                 try {
  2117.                     this.busta.setTipoServizio(this.traduttore.toRegistryServiceType(tipo));
  2118.                 }catch(Exception e) {
  2119.                     this.busta.setTipoServizio(tipo); // senza traduzione
  2120.                     
  2121.                     this.log.warn(e.getMessage(),e);
  2122.                     Eccezione ecc = new Eccezione();
  2123.                     ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  2124.                     ecc.setCodiceEccezione(CodiceErroreCooperazione.TIPO_SERVIZIO_SCONOSCIUTO );
  2125.                     ecc.setRilevanza(LivelloRilevanza.ERROR);
  2126.                     ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_SERVIZIO_SCONOSCIUTO_POSIZIONE_TIPO.toString());
  2127.                     this.erroriValidazione.add(ecc);
  2128.                 }
  2129.                 
  2130.             }
  2131.             
  2132.         }catch(StrutturaBustaException e){
  2133.             throw e;
  2134.         } catch(Exception e) {
  2135.             Eccezione ecc = new Eccezione();
  2136.             ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  2137.             ecc.setCodiceEccezione(CodiceErroreCooperazione.TIPO_SERVIZIO_NON_VALIDO );
  2138.             ecc.setRilevanza(LivelloRilevanza.ERROR);
  2139.             ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_SERVIZIO_SCONOSCIUTO_POSIZIONE_TIPO.toString());
  2140.             this.erroriValidazione.add(ecc);
  2141.         }

  2143.     }

  2145.     /**
  2146.      * Metodo che si occupa di validare l'elemento 'Azione' <var>child</var> secondo specifica eGov.
  2147.      * <p>
  2148.      * Il metodo, oltre ad effettuare la validazione, si occupa anche di leggerne il contenuto e 
  2149.      * di impostarlo all'interno dell'oggetto <var>busta</var>.
  2150.      * Mano mano che sono incontrati errori di validazione, viene creato un oggetto 
  2151.      *    {@link Eccezione}, e viene inserito in errors.
  2152.      *
  2153.      * @param child nodo su cui effettuare la validazione
  2154.      * @throws ProtocolException 
  2155.      * 
  2156.      */
  2157.     private void validazioneAzione(OpenSPCoop2MessageFactory messageFactory, Node child) throws ProtocolException{

  2159.         //log.info("Validazione azione...");

  2161.         if (SoapUtils.getNotEmptyChildNodes(messageFactory, child).size() != 1){
  2162.             Eccezione ecc = new Eccezione();
  2163.             ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  2164.             ecc.setCodiceEccezione(CodiceErroreCooperazione.AZIONE_NON_VALIDA);
  2165.             ecc.setRilevanza(LivelloRilevanza.ERROR);
  2166.             ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_AZIONE_SCONOSCIUTA_POSIZIONE.toString());
  2167.             this.erroriValidazione.add(ecc);
  2168.             return;
  2169.         }

  2171.         String azione = null;
  2172.         try{
  2173.             azione = SoapUtils.getNotEmptyChildNodes(messageFactory, child).get(0).getNodeValue();
  2174.         } catch(Exception e) {
  2175.             Eccezione ecc = new Eccezione();
  2176.             ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  2177.             ecc.setCodiceEccezione(CodiceErroreCooperazione.AZIONE_NON_VALORIZZATA);
  2178.             ecc.setRilevanza(LivelloRilevanza.ERROR);
  2179.             ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_AZIONE_SCONOSCIUTA_POSIZIONE.toString());
  2180.             this.erroriValidazione.add(ecc);
  2181.         }

  2183.         //log.info("Azione["+azione+"]");
  2184.         this.busta.setAzione(azione);
  2185.     }

  2187.     /**
  2188.      * Metodo che si occupa di validare l'elemento 'Messaggio' <var>child</var> secondo specifica eGov.
  2189.      * <p>
  2190.      * Il metodo, oltre ad effettuare la validazione, si occupa anche di leggerne il contenuto e 
  2191.      * di impostarlo all'interno dell'oggetto <var>busta</var>.
  2192.      * Mano mano che sono incontrati errori di validazione, viene creato un oggetto 
  2193.      *    {@link Eccezione}, e viene inserito in errors.
  2194.      *
  2195.      * @param child nodo su cui effettuare la validazione
  2196.      * @throws ProtocolException 
  2197.      * 
  2198.      */
  2199.     private void validazioneMessaggio(OpenSPCoop2MessageFactory messageFactory, Node child,String prefix) throws StrutturaBustaException, ProtocolException{

  2201.         // Prefix eGov
  2202.         String xmlns = getPrefix();

  2204.         //log.info("Validazione Messaggio...");

  2206.         List<Node> contenutoMsg = SoapUtils.getNotEmptyChildNodes(messageFactory, child);
  2207.         if( (contenutoMsg.size() == 0) || (contenutoMsg.size() > 4)){
  2208.             Eccezione ecc = new Eccezione();
  2209.             ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  2210.             ecc.setCodiceEccezione(CodiceErroreCooperazione.FORMATO_INTESTAZIONE_NON_CORRETTO);
  2211.             ecc.setRilevanza(LivelloRilevanza.ERROR);
  2212.             ecc.setDescrizione("IntestazioneMessaggio/Messaggio childsize:"+contenutoMsg.size());
  2213.             this.erroriValidazione.add(ecc);
  2214.         }

  2216.         boolean presenzaID = false;
  2217.         boolean presenzaOra = false;
  2218.         boolean presenzaScadenza = false;
  2219.         boolean presenzaRifMessaggio = false;
  2220.         
  2221.         for(int j =0; j<contenutoMsg.size();j++){
  2222.             Node childMsg = contenutoMsg.get(j);

  2224.             //if((childMsg.getNodeName().equals(xmlns+"Identificatore"))){
  2225.             if(SoapUtils.matchLocalName(messageFactory, childMsg, "Identificatore", xmlns, SPCoopCostanti.NAMESPACE_EGOV)){
  2226.                 
  2227.                 
  2228.                 if(presenzaID){
  2229.                     if(this.spcoopProperties.isGenerazioneBustaErrore_strutturaMalformataHeaderProtocollo()==false){
  2230.                         throw new StrutturaBustaException("Header egov con più di un elemento Identificatore","MessaggioIdentificatore");
  2231.                     }else{
  2232.                         Eccezione ecc = new Eccezione();
  2233.                         ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  2234.                         ecc.setCodiceEccezione(CodiceErroreCooperazione.IDENTIFICATIVO_MESSAGGIO_PRESENTE_PIU_VOLTE);
  2235.                         ecc.setRilevanza(LivelloRilevanza.ERROR);
  2236.                         if(this.segnalazioneElementoPresentePiuVolte)
  2237.                             ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_ID_MESSAGGIO_NON_DEFINITO_POSIZIONE+" "+CostantiProtocollo.ECCEZIONE_ELEMENTO_PRESENTE_PIU_VOLTE);
  2238.                         else
  2239.                             ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_ID_MESSAGGIO_NON_DEFINITO_POSIZIONE.toString());
  2240.                         this.erroriValidazione.add(ecc);
  2241.                         continue;
  2242.                     }
  2243.                 }else{
  2244.                 
  2245.                     //log.info("Validazione identificatore...");
  2246.                     presenzaID = true;
  2247.     
  2248.                     if (SoapUtils.getNotEmptyChildNodes(messageFactory, childMsg).size() != 1){
  2249.                         Eccezione ecc = new Eccezione();
  2250.                         ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  2251.                         ecc.setCodiceEccezione(CodiceErroreCooperazione.IDENTIFICATIVO_MESSAGGIO_NON_VALORIZZATO);
  2252.                         ecc.setRilevanza(LivelloRilevanza.ERROR);
  2253.                         ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_ID_MESSAGGIO_NON_DEFINITO_POSIZIONE.toString());
  2254.                         this.erroriValidazione.add(ecc);
  2255.                         continue;
  2256.                     }
  2257.                     String id = null;
  2258.                     try{
  2259.                         id = SoapUtils.getNotEmptyChildNodes(messageFactory, childMsg).get(0).getNodeValue();
  2260.                     } catch(Exception e) {
  2261.                         Eccezione ecc = new Eccezione();
  2262.                         ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  2263.                         ecc.setCodiceEccezione(CodiceErroreCooperazione.IDENTIFICATIVO_MESSAGGIO_NON_VALORIZZATO);
  2264.                         ecc.setRilevanza(LivelloRilevanza.ERROR);
  2265.                         ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_ID_MESSAGGIO_NON_DEFINITO_POSIZIONE.toString());
  2266.                         this.erroriValidazione.add(ecc);
  2267.                     }
  2268.     
  2269.                     if(id==null){
  2270.                         Eccezione ecc = new Eccezione();
  2271.                         ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  2272.                         ecc.setCodiceEccezione(CodiceErroreCooperazione.IDENTIFICATIVO_MESSAGGIO_NON_VALORIZZATO);
  2273.                         ecc.setRilevanza(LivelloRilevanza.ERROR);
  2274.                         ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_ID_MESSAGGIO_NON_DEFINITO_POSIZIONE.toString());
  2275.                         this.erroriValidazione.add(ecc);
  2276.                     }
  2277.     
  2278.                     //log.info("identificatore["+id+"]");
  2279.                     this.busta.setID(id);
  2280.                 }

  2282.             //}else if((childMsg.getNodeName().equals(xmlns+"OraRegistrazione"))){
  2283.             }else if(SoapUtils.matchLocalName(messageFactory, childMsg, "OraRegistrazione", xmlns, SPCoopCostanti.NAMESPACE_EGOV)){
  2284.                 
  2285.                 if(presenzaOra){
  2286.                     if(this.spcoopProperties.isGenerazioneBustaErrore_strutturaMalformataHeaderProtocollo()==false){
  2287.                         throw new StrutturaBustaException("Header egov con più di un elemento OraRegistrazione","MessaggioOraRegistrazione");
  2288.                     }else{
  2289.                         Eccezione ecc = new Eccezione();
  2290.                         ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  2291.                         ecc.setCodiceEccezione(CodiceErroreCooperazione.ORA_REGISTRAZIONE_PRESENTE_PIU_VOLTE);
  2292.                         ecc.setRilevanza(LivelloRilevanza.ERROR);
  2293.                         if(this.segnalazioneElementoPresentePiuVolte)
  2294.                             ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_ORA_REGISTRAZIONE_NON_VALIDA_POSIZIONE+" "+CostantiProtocollo.ECCEZIONE_ELEMENTO_PRESENTE_PIU_VOLTE);
  2295.                         else
  2296.                             ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_ORA_REGISTRAZIONE_NON_VALIDA_POSIZIONE.toString());
  2297.                         this.erroriValidazione.add(ecc);
  2298.                         continue;
  2299.                     }
  2300.                 }else{
  2301.                 
  2302.                     //log.info("Validazione Ora Registrazione...");
  2303.                     presenzaOra = true;
  2304.     
  2305.                     if (SoapUtils.getNotEmptyChildNodes(messageFactory, childMsg).size() != 1){
  2306.                         Eccezione ecc = new Eccezione();
  2307.                         ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  2308.                         ecc.setCodiceEccezione(CodiceErroreCooperazione.ORA_REGISTRAZIONE_NON_PRESENTE);
  2309.                         ecc.setRilevanza(LivelloRilevanza.ERROR);
  2310.                         ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_ORA_REGISTRAZIONE_NON_VALIDA_POSIZIONE.toString());
  2311.                         this.erroriValidazione.add(ecc);
  2312.                         continue;
  2313.                     }
  2314.                     String ora = null;
  2315.                     try{
  2316.                         ora = SoapUtils.getNotEmptyChildNodes(messageFactory, childMsg).get(0).getNodeValue();
  2317.                     } catch(Exception e) {
  2318.                         Eccezione ecc = new Eccezione();
  2319.                         ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  2320.                         ecc.setCodiceEccezione(CodiceErroreCooperazione.ORA_REGISTRAZIONE_NON_VALORIZZATA);
  2321.                         ecc.setRilevanza(LivelloRilevanza.ERROR);
  2322.                         ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_ORA_REGISTRAZIONE_NON_VALIDA_POSIZIONE.toString());
  2323.                         this.erroriValidazione.add(ecc);
  2324.                         continue;
  2325.                     }
  2326.                     Date oraDate = null;  
  2327.                     if(ora != null){
  2328.                         oraDate = validazioneData(ora);
  2329.                     }
  2330.                     if( (ora==null) || (oraDate == null)){
  2331.                         Eccezione ecc = new Eccezione();
  2332.                         ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  2333.                         ecc.setCodiceEccezione(CodiceErroreCooperazione.ORA_REGISTRAZIONE_NON_VALORIZZATA);
  2334.                         ecc.setRilevanza(LivelloRilevanza.ERROR);
  2335.                         ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_ORA_REGISTRAZIONE_NON_VALIDA_POSIZIONE.toString());
  2336.                         this.erroriValidazione.add(ecc);
  2337.                     }
  2338.     
  2339.                     //log.info("OraRegistrazione["+oraDate+"]");
  2340.                     this.busta.setOraRegistrazione(oraDate);
  2341.     
  2342.                     // tempo ...
  2343.                     String tipoOra = null;
  2344.                     try{
  2345.                         Node hrefFind = null;
  2346.                         if(this.readQualifiedAttribute){
  2347.                             hrefFind = SoapUtils.getQualifiedAttributeNode(messageFactory, childMsg, "tempo", SPCoopCostanti.NAMESPACE_EGOV);
  2348.                         }else{
  2349.                             hrefFind = SoapUtils.getAttributeNode(messageFactory, childMsg, "tempo");
  2350.                         }
  2351.                         tipoOra = hrefFind.getNodeValue();
  2352.                     } catch(Exception e) {
  2353.                         if(this.spcoopProperties.isGenerazioneBustaErrore_strutturaMalformataHeaderProtocollo()==false){
  2354.                             throw new StrutturaBustaException("Header egov senza elemento OraRegistrazione tempo","OraRegistrazioneTempo");
  2355.                         } else {
  2356.                             Eccezione ecc = new Eccezione();
  2357.                             ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  2358.                             ecc.setCodiceEccezione(CodiceErroreCooperazione.TIPO_ORA_REGISTRAZIONE_NON_VALIDA);
  2359.                             ecc.setRilevanza(LivelloRilevanza.ERROR);
  2360.                             ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_ORA_REGISTRAZIONE_NON_VALIDA_POSIZIONE_TEMPO.toString());
  2361.                             this.erroriValidazione.add(ecc);
  2362.                         }
  2363.                     }
  2364.                     if(tipoOra!=null){
  2365.                         if(!tipoOra.equals(SPCoopCostanti.TIPO_TEMPO_LOCALE) && !tipoOra.equals(SPCoopCostanti.TIPO_TEMPO_SPC)){
  2366.                             Eccezione ecc = new Eccezione();
  2367.                             ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  2368.                             ecc.setCodiceEccezione(CodiceErroreCooperazione.TIPO_ORA_REGISTRAZIONE_SCONOSCIUTA);
  2369.                             ecc.setRilevanza(LivelloRilevanza.ERROR);
  2370.                             ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_ORA_REGISTRAZIONE_NON_VALIDA_POSIZIONE_TEMPO.toString());
  2371.                             this.erroriValidazione.add(ecc);
  2372.                         }
  2373.                     }
  2374.                     this.busta.setTipoOraRegistrazione(toTipoOra(tipoOra), tipoOra);
  2375.                 }

  2377.             //}else if((childMsg.getNodeName().equals(xmlns+"RiferimentoMessaggio"))){
  2378.             }else if(SoapUtils.matchLocalName(messageFactory, childMsg, "RiferimentoMessaggio", xmlns, SPCoopCostanti.NAMESPACE_EGOV)){ 
  2379.                 //log.info("Validazione RiferimentoMessaggio...");

  2381.                 if(presenzaRifMessaggio){
  2382.                     if(this.spcoopProperties.isGenerazioneBustaErrore_strutturaMalformataHeaderProtocollo()==false){
  2383.                         throw new StrutturaBustaException("Header egov con più di un elemento RiferimentoMessaggio","MessaggioRiferimentoMessaggio");
  2384.                     }else{
  2385.                         Eccezione ecc = new Eccezione();
  2386.                         ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  2387.                         ecc.setCodiceEccezione(CodiceErroreCooperazione.RIFERIMENTO_MESSAGGIO_PRESENTE_PIU_VOLTE);
  2388.                         ecc.setRilevanza(LivelloRilevanza.ERROR);
  2389.                         if(this.segnalazioneElementoPresentePiuVolte)
  2390.                             ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_RIFERIMENTO_MESSAGGIO_NON_DEFINITO_POSIZIONE+" "+CostantiProtocollo.ECCEZIONE_ELEMENTO_PRESENTE_PIU_VOLTE);
  2391.                         else
  2392.                             ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_RIFERIMENTO_MESSAGGIO_NON_DEFINITO_POSIZIONE.toString());
  2393.                         this.erroriValidazione.add(ecc);
  2394.                         continue;
  2395.                     }
  2396.                 }else{
  2397.                 
  2398.                     presenzaRifMessaggio = true;
  2399.                     
  2400.                     if (SoapUtils.getNotEmptyChildNodes(messageFactory, childMsg).size() != 1){
  2401.                         Eccezione ecc = new Eccezione();
  2402.                         ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  2403.                         ecc.setCodiceEccezione(CodiceErroreCooperazione.RIFERIMENTO_MESSAGGIO_NON_VALORIZZATO);
  2404.                         ecc.setRilevanza(LivelloRilevanza.ERROR);
  2405.                         ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_RIFERIMENTO_MESSAGGIO_NON_DEFINITO_POSIZIONE.toString());
  2406.                         this.erroriValidazione.add(ecc);
  2407.                         continue;
  2408.                     }
  2409.                     String rifID = null;
  2410.                     try{
  2411.                         rifID = SoapUtils.getNotEmptyChildNodes(messageFactory, childMsg).get(0).getNodeValue();
  2412.                     } catch(Exception e) {
  2413.                         Eccezione ecc = new Eccezione();
  2414.                         ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  2415.                         ecc.setCodiceEccezione(CodiceErroreCooperazione.RIFERIMENTO_MESSAGGIO_NON_VALORIZZATO);
  2416.                         ecc.setRilevanza(LivelloRilevanza.ERROR);
  2417.                         ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_RIFERIMENTO_MESSAGGIO_NON_DEFINITO_POSIZIONE.toString());
  2418.                         this.erroriValidazione.add(ecc);
  2419.                     }
  2420.     
  2421.                     if(rifID==null){
  2422.                         Eccezione ecc = new Eccezione();
  2423.                         ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  2424.                         ecc.setCodiceEccezione(CodiceErroreCooperazione.RIFERIMENTO_MESSAGGIO_NON_VALORIZZATO);
  2425.                         ecc.setRilevanza(LivelloRilevanza.ERROR);
  2426.                         ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_RIFERIMENTO_MESSAGGIO_NON_DEFINITO_POSIZIONE.toString());
  2427.                         this.erroriValidazione.add(ecc);
  2428.                     }
  2429.     
  2430.                     //log.info("RiferimentoMessaggio["+rifID+"]");
  2431.                     this.busta.setRiferimentoMessaggio(rifID);
  2432.                 }

  2434.             //}else if((childMsg.getNodeName().equals(xmlns+"Scadenza"))){
  2435.             }else if(SoapUtils.matchLocalName(messageFactory, childMsg, "Scadenza", xmlns, SPCoopCostanti.NAMESPACE_EGOV)){
  2436.                 //log.info("Validazione Scadenza...");

  2438.                 if(presenzaScadenza){
  2439.                     if(this.spcoopProperties.isGenerazioneBustaErrore_strutturaMalformataHeaderProtocollo()==false){
  2440.                         throw new StrutturaBustaException("Header egov con più di un elemento Scadenza","MessaggioScadenza");
  2441.                     }else{
  2442.                         Eccezione ecc = new Eccezione();
  2443.                         ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  2444.                         ecc.setCodiceEccezione(CodiceErroreCooperazione.SCADENZA_PRESENTE_PIU_VOLTE);
  2445.                         ecc.setRilevanza(LivelloRilevanza.ERROR);
  2446.                         if(this.segnalazioneElementoPresentePiuVolte)
  2447.                             ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_SCADENZA_NON_VALIDA_POSIZIONE+" "+CostantiProtocollo.ECCEZIONE_ELEMENTO_PRESENTE_PIU_VOLTE);
  2448.                         else
  2449.                             ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_SCADENZA_NON_VALIDA_POSIZIONE.toString());
  2450.                         this.erroriValidazione.add(ecc);
  2451.                         continue;
  2452.                     }
  2453.                 }else{
  2454.                     
  2455.                     presenzaScadenza = true;
  2456.                     
  2457.                     if (SoapUtils.getNotEmptyChildNodes(messageFactory, childMsg).size() != 1){
  2458.                         Eccezione ecc = new Eccezione();
  2459.                         ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  2460.                         ecc.setCodiceEccezione(CodiceErroreCooperazione.SCADENZA_NON_PRESENTE);
  2461.                         ecc.setRilevanza(LivelloRilevanza.ERROR);
  2462.                         ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_SCADENZA_NON_VALIDA_POSIZIONE.toString());
  2463.                         this.erroriValidazione.add(ecc);
  2464.                         continue;
  2465.                     }
  2466.                     String scadenza = null;
  2467.                     try{
  2468.                         scadenza = SoapUtils.getNotEmptyChildNodes(messageFactory, childMsg).get(0).getNodeValue();
  2469.                     } catch(Exception e) {
  2470.                         Eccezione ecc = new Eccezione();
  2471.                         ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  2472.                         ecc.setCodiceEccezione(CodiceErroreCooperazione.SCADENZA_NON_VALIDA);
  2473.                         ecc.setRilevanza(LivelloRilevanza.ERROR);
  2474.                         ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_SCADENZA_NON_VALIDA_POSIZIONE.toString());
  2475.                         this.erroriValidazione.add(ecc);
  2476.                         continue;
  2477.                     }
  2478.                     Date scadenzaDate = null; 
  2479.                     if(scadenza != null){
  2480.                         scadenzaDate = validazioneData(scadenza);
  2481.                     }
  2482.                     if( (scadenza==null) || (scadenzaDate == null)){
  2483.                         Eccezione ecc = new Eccezione();
  2484.                         ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  2485.                         ecc.setCodiceEccezione(CodiceErroreCooperazione.SCADENZA_NON_VALORIZZATA);
  2486.                         ecc.setRilevanza(LivelloRilevanza.ERROR);
  2487.                         ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_SCADENZA_NON_VALIDA_POSIZIONE.toString());
  2488.                         this.erroriValidazione.add(ecc);
  2489.                         continue;
  2490.                     }
  2491.                     if( dataScaduta(scadenza) == true){
  2492.                         this.messaggioScaduto = true;
  2493.                         Eccezione ecc = new Eccezione();
  2494.                         ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  2495.                         ecc.setCodiceEccezione(CodiceErroreCooperazione.MESSAGGIO_SCADUTO);
  2496.                         ecc.setRilevanza(LivelloRilevanza.ERROR);
  2497.                         ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_SCADENZA_NON_VALIDA_POSIZIONE.toString());
  2498.                         this.erroriValidazione.add(ecc);
  2499.                     }
  2500.     
  2501.                     //log.info("Scadenza["+scadenzaDate+"]");
  2502.                     this.busta.setScadenza(scadenzaDate);
  2503.                 }

  2505.             }else{ 
  2506.                 Eccezione ecc = new Eccezione();
  2507.                 ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  2508.                 ecc.setCodiceEccezione(CodiceErroreCooperazione.FORMATO_INTESTAZIONE_NON_CORRETTO);
  2509.                 ecc.setRilevanza(LivelloRilevanza.ERROR);
  2510.                 ecc.setDescrizione("IntestazioneMessaggio/Messaggio/child["+childMsg.getNodeName()+"]");
  2511.                 this.erroriValidazione.add(ecc);
  2512.             }
  2513.         }

  2515.         if(presenzaID == false){ 
  2516.             Eccezione ecc = new Eccezione();
  2517.             ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  2518.             ecc.setCodiceEccezione(CodiceErroreCooperazione.IDENTIFICATIVO_MESSAGGIO_NON_PRESENTE);
  2519.             ecc.setRilevanza(LivelloRilevanza.ERROR);
  2520.             ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_ID_MESSAGGIO_NON_DEFINITO_POSIZIONE.toString());
  2521.             this.erroriValidazione.add(ecc);
  2522.         }
  2523.         if(presenzaOra == false){ 
  2524.             Eccezione ecc = new Eccezione();
  2525.             ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  2526.             ecc.setCodiceEccezione(CodiceErroreCooperazione.ORA_REGISTRAZIONE_NON_PRESENTE);
  2527.             ecc.setRilevanza(LivelloRilevanza.ERROR);
  2528.             ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_ORA_REGISTRAZIONE_NON_VALIDA_POSIZIONE.toString());
  2529.             this.erroriValidazione.add(ecc);
  2530.         }
  2531.     }



  2535.     /**
  2536.      * Metodo che si occupa di validare l'elemento 'ProfiloTrasmissione' <var>child</var> secondo specifica eGov.
  2537.      * Il metodo, oltre ad effettuare la validazione, si occupa anche di leggerne il contenuto e 
  2538.      * di impostarlo all'interno dell'oggetto <var>busta</var>.
  2539.      * Mano mano che sono incontrati errori di validazione, viene creato un oggetto 
  2540.      *    {@link Eccezione}, e viene inserito in errors.
  2541.      *
  2542.      * @param child nodo su cui effettuare la validazione
  2543.      * @throws ProtocolException 
  2544.      * 
  2545.      */
  2546.     private void validazioneProfiloTrasmissione(OpenSPCoop2MessageFactory messageFactory, Node child,String prefix) throws ProtocolException{

  2548.         //log.info("Validazione profilo Trasmissione...");

  2550.         if (SoapUtils.getNotEmptyChildNodes(messageFactory, child).size() != 0){
  2551.             Eccezione ecc = new Eccezione();
  2552.             ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  2553.             ecc.setCodiceEccezione(CodiceErroreCooperazione.PROFILO_TRASMISSIONE_NON_VALIDO);
  2554.             ecc.setRilevanza(LivelloRilevanza.ERROR);
  2555.             ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_PROFILO_TRASMISSIONE_NON_VALIDO_POSIZIONE+" child size:"+SoapUtils.getNotEmptyChildNodes(messageFactory,child).size());
  2556.             this.erroriValidazione.add(ecc);
  2557.         }
  2558.         String inoltro = null;
  2559.         String confermaRicezione = null;
  2560.         try{
  2561.             Node hrefFind = null;
  2562.             if(this.readQualifiedAttribute){
  2563.                 hrefFind = SoapUtils.getQualifiedAttributeNode(messageFactory, child, "inoltro", SPCoopCostanti.NAMESPACE_EGOV);
  2564.             }else{
  2565.                 hrefFind = SoapUtils.getAttributeNode(messageFactory, child, "inoltro");
  2566.             }
  2567.             inoltro = hrefFind.getNodeValue();
  2568.             //log.info("Inoltro ["+inoltro+"]");
  2569.         } catch(Exception e) {
  2570.             // ignore
  2571.         }
  2572.         try{
  2573.             Node hrefFind = null;
  2574.             if(this.readQualifiedAttribute){
  2575.                 hrefFind = SoapUtils.getQualifiedAttributeNode(messageFactory, child, "confermaRicezione", SPCoopCostanti.NAMESPACE_EGOV);
  2576.             }else{
  2577.                 hrefFind = SoapUtils.getAttributeNode(messageFactory, child, "confermaRicezione");
  2578.             }
  2579.             confermaRicezione = hrefFind.getNodeValue();
  2580.             //log.info("confermaRicezione ["+confermaRicezione+"]");
  2581.         } catch(Exception e) {
  2582.             // ignore
  2583.         }

  2585.         // Inoltro...
  2586.         if(inoltro == null ){
  2587.             // Default: EGOV_IT_PIUDIUNAVOLTA
  2588.             inoltro = SPCoopCostanti.PROFILO_TRASMISSIONE_CON_DUPLICATI;
  2589.         } else {
  2590.             if( (inoltro.equals(SPCoopCostanti.PROFILO_TRASMISSIONE_SENZA_DUPLICATI) == false ) &&
  2591.                     (inoltro.equals(SPCoopCostanti.PROFILO_TRASMISSIONE_CON_DUPLICATI) == false )  ){
  2592.                 Eccezione ecc = new Eccezione();
  2593.                 ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  2594.                 ecc.setCodiceEccezione(CodiceErroreCooperazione.PROFILO_TRASMISSIONE_FILTRO_DUPLICATI_SCONOSCIUTO);
  2595.                 ecc.setRilevanza(LivelloRilevanza.ERROR);
  2596.                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_PROFILO_TRASMISSIONE_NON_VALIDO_POSIZIONE_INOLTRO.toString());
  2597.                 this.erroriValidazione.add(ecc);
  2598.             }
  2599.         }

  2601.         // ConfermaRicezione...
  2602.         if(confermaRicezione == null ){
  2603.             // Default: false
  2604.             confermaRicezione = "false";
  2605.         }else{
  2606.             if( (confermaRicezione.equals("true") == false ) &&
  2607.                     (confermaRicezione.equals("false") == false )  ){
  2608.                 Eccezione ecc = new Eccezione();
  2609.                 ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  2610.                 ecc.setCodiceEccezione(CodiceErroreCooperazione.PROFILO_TRASMISSIONE_CONFERMA_RICEZIONE_SCONOSCIUTO);
  2611.                 ecc.setRilevanza(LivelloRilevanza.ERROR);
  2612.                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_PROFILO_TRASMISSIONE_NON_VALIDO_POSIZIONE_CONFERMA_RICEZIONE.toString());
  2613.                 this.erroriValidazione.add(ecc);
  2614.             }
  2615.         }

  2617.         // set
  2618.         this.busta.setInoltro(toInoltro(inoltro), inoltro);
  2619.         if(confermaRicezione.equals("true"))
  2620.             this.busta.setConfermaRicezione(true);
  2621.         else
  2622.             this.busta.setConfermaRicezione(false);

  2624.     }

  2626.     /**
  2627.      * Metodo che si occupa di validare l'elemento 'Sequenza' <var>child</var> secondo specifica eGov.
  2628.      * <p>
  2629.      * Il metodo, oltre ad effettuare la validazione, si occupa anche di leggerne il contenuto e 
  2630.      * di impostarlo all'interno dell'oggetto <var>busta</var>.
  2631.      * Mano mano che sono incontrati errori di validazione, viene creato un oggetto 
  2632.      *    {@link Eccezione}, e viene inserito in errors.
  2633.      *
  2634.      * @param child nodo su cui effettuare la validazione
  2635.      * @throws ProtocolException 
  2636.      * 
  2637.      */
  2638.     private void validazioneSequenza(OpenSPCoop2MessageFactory messageFactory, Node child,String prefix) throws StrutturaBustaException, ProtocolException{

  2640.         //log.info("Validazione sequenza...");

  2642.         if (SoapUtils.getNotEmptyChildNodes(messageFactory, child).size() != 0){
  2643.             Eccezione ecc = new Eccezione();
  2644.             ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  2645.             ecc.setCodiceEccezione(CodiceErroreCooperazione.CONSEGNA_IN_ORDINE_NON_VALIDA);
  2646.             ecc.setRilevanza(LivelloRilevanza.ERROR);
  2647.             ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_SEQUENZA_NON_VALIDA_POSIZIONE.toString());
  2648.             this.erroriValidazione.add(ecc);
  2649.         }
  2650.         String seq = null;
  2651.         try{
  2652.             Node hrefFind = null;
  2653.             if(this.readQualifiedAttribute){
  2654.                 hrefFind = SoapUtils.getQualifiedAttributeNode(messageFactory, child, "numeroProgressivo", SPCoopCostanti.NAMESPACE_EGOV);
  2655.             }else{
  2656.                 hrefFind = SoapUtils.getAttributeNode(messageFactory, child, "numeroProgressivo");
  2657.             }
  2658.             seq = hrefFind.getNodeValue();
  2659.             //log.info("Sequenza ["+seq+"]");
  2660.         } catch(Exception e) {
  2661.             // ignore
  2662.         }

  2664.         if(seq == null ){
  2665.             if(this.spcoopProperties.isGenerazioneBustaErrore_strutturaMalformataHeaderProtocollo()==false){
  2666.                 throw new StrutturaBustaException("Header egov senza elemento Sequenza numeroProgressivo","SequenzaNumeroProgressivo");
  2667.             } else {
  2668.                 Eccezione ecc = new Eccezione();
  2669.                 ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  2670.                 ecc.setCodiceEccezione(CodiceErroreCooperazione.CONSEGNA_IN_ORDINE_NON_VALORIZZATA);
  2671.                 ecc.setRilevanza(LivelloRilevanza.ERROR);
  2672.                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_SEQUENZA_NON_VALIDA_POSIZIONE_NUMERO_PROGRESSIVO.toString());
  2673.                 this.erroriValidazione.add(ecc);
  2674.                 return;
  2675.             }
  2676.         }

  2678.         try{
  2679.             Long test = Long.valueOf(seq);
  2680.             this.busta.setSequenza(test.longValue());
  2681.         } catch(Exception e) {
  2682.             Eccezione ecc = new Eccezione();
  2683.             ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  2684.             ecc.setCodiceEccezione(CodiceErroreCooperazione.CONSEGNA_IN_ORDINE_NON_VALIDA);
  2685.             ecc.setRilevanza(LivelloRilevanza.ERROR);
  2686.             ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_SEQUENZA_NON_VALIDA_POSIZIONE_NUMERO_PROGRESSIVO.toString());
  2687.             this.erroriValidazione.add(ecc);
  2688.         }


  2691.     }

  2693.     /**
  2694.      * Metodo che si occupa di validare la lista Riscontri <var>child</var> secondo specifica eGov.
  2695.      * <p>
  2696.      * Il metodo, oltre ad effettuare la validazione, si occupa anche di leggerne il contenuto e 
  2697.      * di impostarlo all'interno dell'oggetto <var>busta</var>.
  2698.      * Mano mano che sono incontrati errori di validazione, viene creato un oggetto 
  2699.      *    {@link Eccezione}, e viene inserito in errors.
  2700.      *
  2701.      * @param child nodo su cui effettuare la validazione
  2702.      * @throws ProtocolException 
  2703.      * 
  2704.      */
  2705.     private void validazioneListaRiscontri(OpenSPCoop2MessageFactory messageFactory, Node child,String prefix) throws StrutturaBustaException, ProtocolException{

  2707.         //log.info("Validazione Lista Riscontri...");
  2708.         List<Node> riscontri = SoapUtils.getNotEmptyChildNodes(messageFactory, child);

  2710.         if(riscontri.size() <= 0 ){        
  2711.             Eccezione ecc = new Eccezione();
  2712.             ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  2713.             ecc.setCodiceEccezione(CodiceErroreCooperazione.LISTA_RISCONTRI_NON_VALORIZZATA);
  2714.             ecc.setRilevanza(LivelloRilevanza.ERROR);
  2715.             ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_RISCONTRI_NON_VALIDA_POSIZIONE_RISCONTRO.toString());
  2716.             this.erroriValidazione.add(ecc);
  2717.             return;
  2718.         }
  2719.         
  2720.         for(int i=0; i<riscontri.size();i++){

  2722.             boolean errorFind = false;

  2724.             Node riscontro = riscontri.get(i);
  2725.             //log.info("esamino["+child.getNodeName()+"]");
  2726.             //if(!(riscontro.getNodeName().equals(xmlns+"Riscontro"))){
  2727.             if(!(SoapUtils.matchLocalName(messageFactory, riscontro, "Riscontro", prefix, SPCoopCostanti.NAMESPACE_EGOV))){
  2728.                 Eccezione ecc = new Eccezione();
  2729.                 ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  2730.                 ecc.setCodiceEccezione(CodiceErroreCooperazione.RISCONTRO_NON_VALIDO);
  2731.                 ecc.setRilevanza(LivelloRilevanza.ERROR);
  2732.                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_RISCONTRI_NON_VALIDA_POSIZIONE+"/childNode["+riscontro.getNodeName()+"]");
  2733.                 this.erroriValidazione.add(ecc);
  2734.                 continue;
  2735.             }

  2737.             List<Node> childsRiscontro = SoapUtils.getNotEmptyChildNodes(messageFactory, riscontro);
  2738.             /*if(childsRiscontro.getLength() != 2){        
  2739.                 Eccezione ecc = new Eccezione();
  2740.                 ecc.setContestoCodifica(Costanti.CONTESTO_CODIFICA_ECCEZIONE_VALIDAZIONE);
  2741.                 ecc.setCodiceEccezione(Costanti.ECCEZIONE_LISTA_RISCONTRI_NON_VALIDA);
  2742.                 ecc.setRilevanza(LivelloRilevanza.GRAVE);
  2743.                 ecc.setDescrizione(Costanti.ECCEZIONE_LISTA_RISCONTRI_NON_VALIDA_POSIZIONE_RISCONTRO+" child size:"+childsRiscontro.getLength());
  2744.                 this.erroriValidazione.add(ecc);
  2745.                 continue;
  2746.             }*/

  2748.             boolean presenzaIdentificatore = false;
  2749.             boolean presenzaOraRegistrazione = false;
  2750.             
  2751.             String id = null;
  2752.             boolean findID = false;
  2753.             String ora = null;
  2754.             Date oraDate = null;
  2755.             boolean findOra = false;
  2756.             String tipoOra = null;
  2757.             boolean findTipoOra = false;
  2758.             for(int j=0; j<childsRiscontro.size();j++){
  2759.                 Node elem = childsRiscontro.get(j);
  2760.                 //if(elem.getNodeName().equals(xmlns+"Identificatore")){
  2761.                 if(SoapUtils.matchLocalName(messageFactory, elem, "Identificatore", prefix, SPCoopCostanti.NAMESPACE_EGOV)){
  2762.                     
  2763.                     if(presenzaIdentificatore){
  2764.                         if(this.spcoopProperties.isGenerazioneBustaErrore_strutturaMalformataHeaderProtocollo()==false){
  2765.                             throw new StrutturaBustaException("Header egov con più di un elemento RiscontroIdentificatore","RiscontroIdentificatore");
  2766.                         }else{
  2767.                             Eccezione ecc = new Eccezione();
  2768.                             ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  2769.                             ecc.setCodiceEccezione(CodiceErroreCooperazione.RISCONTRO_IDENTIFICATIVO_MESSAGGIO_PRESENTE_PIU_VOLTE);
  2770.                             ecc.setRilevanza(LivelloRilevanza.ERROR);
  2771.                             if(this.segnalazioneElementoPresentePiuVolte)
  2772.                                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_RISCONTRI_NON_VALIDA_POSIZIONE_RISCONTRO_IDENTIFICATORE+" "+CostantiProtocollo.ECCEZIONE_ELEMENTO_PRESENTE_PIU_VOLTE);
  2773.                             else
  2774.                                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_RISCONTRI_NON_VALIDA_POSIZIONE_RISCONTRO_IDENTIFICATORE.toString());
  2775.                             this.erroriValidazione.add(ecc);
  2776.                             continue;
  2777.                         }
  2778.                     }else{
  2779.                     
  2780.                         presenzaIdentificatore = true;
  2781.                     
  2782.                         try{
  2783.                             id = SoapUtils.getNotEmptyChildNodes(messageFactory, elem).get(0).getNodeValue();
  2784.                             findID = true;
  2785.                         } catch(Exception e) {
  2786.                             Eccezione ecc = new Eccezione();
  2787.                             ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  2788.                             ecc.setCodiceEccezione(CodiceErroreCooperazione.RISCONTRO_IDENTIFICATIVO_MESSAGGIO_NON_VALIDO);
  2789.                             ecc.setRilevanza(LivelloRilevanza.ERROR);
  2790.                             ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_RISCONTRI_NON_VALIDA_POSIZIONE_RISCONTRO_IDENTIFICATORE.toString());
  2791.                             this.erroriValidazione.add(ecc);
  2792.                             errorFind = true;
  2793.                         }
  2794.                     }
  2795.                 //}else if(elem.getNodeName().equals(xmlns+"OraRegistrazione")){
  2796.                 }else if(SoapUtils.matchLocalName(messageFactory, elem, "OraRegistrazione", prefix, SPCoopCostanti.NAMESPACE_EGOV)){
  2797.                     if(presenzaOraRegistrazione){
  2798.                         if(this.spcoopProperties.isGenerazioneBustaErrore_strutturaMalformataHeaderProtocollo()==false){
  2799.                             throw new StrutturaBustaException("Header egov con più di un elemento RiscontroOraRegistrazione","RiscontroOraRegistrazione");
  2800.                         }else{
  2801.                             Eccezione ecc = new Eccezione();
  2802.                             ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  2803.                             ecc.setCodiceEccezione(CodiceErroreCooperazione.RISCONTRO_ORA_REGISTRAZIONE_PRESENTE_PIU_VOLTE);
  2804.                             ecc.setRilevanza(LivelloRilevanza.ERROR);
  2805.                             if(this.segnalazioneElementoPresentePiuVolte)
  2806.                                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_RISCONTRI_NON_VALIDA_POSIZIONE_RISCONTRO_ORA_REGISTRAZIONE+" "+CostantiProtocollo.ECCEZIONE_ELEMENTO_PRESENTE_PIU_VOLTE);
  2807.                             else
  2808.                                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_RISCONTRI_NON_VALIDA_POSIZIONE_RISCONTRO_ORA_REGISTRAZIONE.toString());
  2809.                             this.erroriValidazione.add(ecc);
  2810.                             continue;
  2811.                         }
  2812.                     }else{
  2813.                         presenzaOraRegistrazione = true;
  2814.                     
  2815.                         try{
  2816.                             ora = SoapUtils.getNotEmptyChildNodes(messageFactory, elem).get(0).getNodeValue();
  2817.                             findOra = true;
  2818.                         } catch(Exception e) {
  2819.                             Eccezione ecc = new Eccezione();
  2820.                             ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  2821.                             ecc.setCodiceEccezione(CodiceErroreCooperazione.RISCONTRO_ORA_REGISTRAZIONE_NON_VALIDA);
  2822.                             ecc.setRilevanza(LivelloRilevanza.ERROR);
  2823.                             ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_RISCONTRI_NON_VALIDA_POSIZIONE_RISCONTRO_ORA_REGISTRAZIONE.toString());
  2824.                             this.erroriValidazione.add(ecc);
  2825.                             errorFind = true;
  2826.                         }
  2827.                         oraDate = null;
  2828.                         if(ora!=null){
  2829.                             oraDate = validazioneData(ora);
  2830.                         }
  2831.                         if( (ora == null) || (oraDate==null)){
  2832.                             Eccezione ecc = new Eccezione();
  2833.                             ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  2834.                             ecc.setCodiceEccezione(CodiceErroreCooperazione.RISCONTRO_ORA_REGISTRAZIONE_NON_VALIDA);
  2835.                             ecc.setRilevanza(LivelloRilevanza.ERROR);
  2836.                             ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_RISCONTRI_NON_VALIDA_POSIZIONE_RISCONTRO_ORA_REGISTRAZIONE.toString());
  2837.                             this.erroriValidazione.add(ecc);
  2838.                             errorFind = true;
  2839.                         }
  2840.     
  2841.                         // tempo ...
  2842.                         try{
  2843.                             Node hrefFind = null;
  2844.                             if(this.readQualifiedAttribute){
  2845.                                 hrefFind = SoapUtils.getQualifiedAttributeNode(messageFactory, elem, "tempo", SPCoopCostanti.NAMESPACE_EGOV);
  2846.                             }else{
  2847.                                 hrefFind = SoapUtils.getAttributeNode(messageFactory, elem, "tempo");
  2848.                             }
  2849.                             tipoOra = hrefFind.getNodeValue();
  2850.                             findTipoOra = true;
  2851.                         } catch(Exception e) {
  2852.                             if(this.spcoopProperties.isGenerazioneBustaErrore_strutturaMalformataHeaderProtocollo()==false){
  2853.                                 throw new StrutturaBustaException("Header egov senza RiscontroOraRegistrazioneTempo","RiscontroOraRegistrazioneTempo");
  2854.                             }else{
  2855.                                 Eccezione ecc = new Eccezione();
  2856.                                 ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  2857.                                 ecc.setCodiceEccezione(CodiceErroreCooperazione.RISCONTRO_TIPO_ORA_REGISTRAZIONE_NON_VALIDO);
  2858.                                 ecc.setRilevanza(LivelloRilevanza.ERROR);
  2859.                                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_RISCONTRI_NON_VALIDA_POSIZIONE_RISCONTRO_ORA_REGISTRAZIONE_TEMPO.toString());
  2860.                                 this.erroriValidazione.add(ecc);
  2861.                                 errorFind = true;
  2862.                             }
  2863.                         }
  2864.                         if(tipoOra!=null){
  2865.                             if(!tipoOra.equals(SPCoopCostanti.TIPO_TEMPO_LOCALE) && !tipoOra.equals(SPCoopCostanti.TIPO_TEMPO_SPC)){
  2866.                                 Eccezione ecc = new Eccezione();
  2867.                                 ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  2868.                                 ecc.setCodiceEccezione(CodiceErroreCooperazione.RISCONTRO_TIPO_ORA_REGISTRAZIONE_SCONOSCIUTO);
  2869.                                 ecc.setRilevanza(LivelloRilevanza.ERROR);
  2870.                                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_RISCONTRI_NON_VALIDA_POSIZIONE_RISCONTRO_ORA_REGISTRAZIONE_TEMPO.toString());
  2871.                                 this.erroriValidazione.add(ecc);
  2872.                                 errorFind = true;
  2873.                             }
  2874.                         }
  2875.                     }
  2876.                 }else {
  2877.                     Eccezione ecc = new Eccezione();
  2878.                     ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  2879.                     ecc.setCodiceEccezione(CodiceErroreCooperazione.LISTA_RISCONTRI_NON_VALIDA);
  2880.                     ecc.setRilevanza(LivelloRilevanza.ERROR);
  2881.                     ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_RISCONTRI_NON_VALIDA_POSIZIONE_RISCONTRO+"/child["+elem.getNodeName()+"]");
  2882.                     this.erroriValidazione.add(ecc);
  2883.                     errorFind = true;
  2884.                 }
  2885.             }

  2887.             if(this.spcoopProperties.isGenerazioneBustaErrore_strutturaMalformataHeaderProtocollo()==false){
  2888.                 if(presenzaIdentificatore == false){
  2889.                     throw new StrutturaBustaException("Header egov senza RiscontroIdentificatore","RiscontroIdentificatore");
  2890.                 }
  2891.                 if(presenzaOraRegistrazione == false){
  2892.                     throw new StrutturaBustaException("Header egov senza RiscontroOraRegistrazione","RiscontroOraRegistrazione");
  2893.                 }
  2894.             }
  2895.             
  2896.             if(errorFind==false){
  2897.                 if(findID != true){
  2898.                     Eccezione ecc = new Eccezione();
  2899.                     ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  2900.                     ecc.setCodiceEccezione(CodiceErroreCooperazione.RISCONTRO_IDENTIFICATIVO_MESSAGGIO_NON_PRESENTE);
  2901.                     ecc.setRilevanza(LivelloRilevanza.ERROR);
  2902.                     ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_RISCONTRI_NON_VALIDA_POSIZIONE_RISCONTRO_IDENTIFICATORE.toString());
  2903.                     this.erroriValidazione.add(ecc);
  2904.                 }
  2905.                 if(findOra != true){
  2906.                     Eccezione ecc = new Eccezione();
  2907.                     ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  2908.                     ecc.setCodiceEccezione(CodiceErroreCooperazione.RISCONTRO_ORA_REGISTRAZIONE_NON_PRESENTE);
  2909.                     ecc.setRilevanza(LivelloRilevanza.ERROR);
  2910.                     ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_RISCONTRI_NON_VALIDA_POSIZIONE_RISCONTRO_ORA_REGISTRAZIONE.toString());
  2911.                     this.erroriValidazione.add(ecc);
  2912.                 }else{
  2913.                     if(findTipoOra != true){
  2914.                         Eccezione ecc = new Eccezione();
  2915.                         ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  2916.                         ecc.setCodiceEccezione(CodiceErroreCooperazione.RISCONTRO_TIPO_ORA_REGISTRAZIONE_NON_PRESENTE);
  2917.                         ecc.setRilevanza(LivelloRilevanza.ERROR);
  2918.                         ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_RISCONTRI_NON_VALIDA_POSIZIONE_RISCONTRO_ORA_REGISTRAZIONE_TEMPO.toString());
  2919.                         this.erroriValidazione.add(ecc);
  2920.                     }
  2921.                 }
  2922.             }
  2923.             

  2925.             //if(id!=null && ora!=null && tipoOra !=null) {
  2926.             if(id!=null || ora!=null || tipoOra !=null) {
  2927.                 Riscontro r = new Riscontro();
  2928.                 r.setID(id);        
  2929.                 //log.info("ORA REC["+oraDate+"]");
  2930.                 r.setOraRegistrazione(oraDate);
  2931.                 r.setTipoOraRegistrazioneValue(tipoOra);
  2932.                 r.setTipoOraRegistrazione(this.traduttore.toTipoOraRegistrazione(tipoOra));
  2933.                 this.busta.addRiscontro(r);
  2934.             }
  2935.         }

  2937.     }


  2940.     /**
  2941.      * Metodo che si occupa di validare la lista Trasmissioni <var>child</var> secondo specifica eGov.
  2942.      * <p>
  2943.      * Il metodo, oltre ad effettuare la validazione, si occupa anche di leggerne il contenuto e 
  2944.      * di impostarlo all'interno dell'oggetto <var>busta</var>.
  2945.      * Mano mano che sono incontrati errori di validazione, viene creato un oggetto 
  2946.      *    {@link Eccezione}, e viene inserito in errors.
  2947.      *
  2948.      * @param child nodo su cui effettuare la validazione
  2949.      * @throws ProtocolException 
  2950.      * 
  2951.      */
  2952.     private void validazioneListaTrasmissioni(OpenSPCoop2MessageFactory messageFactory, Node child,String prefix) throws StrutturaBustaException, ProtocolException{
  2953.         
  2954.         //  log.info("Validazione Lista Trasmissioni...");
  2955.         List<Node> trasmissioni = SoapUtils.getNotEmptyChildNodes(messageFactory, child);

  2957.         if(trasmissioni.size()<=0){
  2958.             Eccezione ecc = new Eccezione();
  2959.             ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  2960.             ecc.setCodiceEccezione(CodiceErroreCooperazione.LISTA_TRASMISSIONI_NON_VALORIZZATA);
  2961.             ecc.setRilevanza(LivelloRilevanza.ERROR);
  2962.             ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_TRASMISSIONI_NON_VALIDA_POSIZIONE_TRASMISSIONE.toString());
  2963.             this.erroriValidazione.add(ecc);
  2964.             return;
  2965.         }
  2966.         
  2967.         for(int i=0; i<trasmissioni.size();i++){

  2969.             boolean errorFind = false;

  2971.             Node trasmissione = trasmissioni.get(i);
  2972.             //log.info("esamino["+child.getNodeName()+"]");
  2973.             //if(!(trasmissione.getNodeName().equals(xmlns+"Trasmissione"))){
  2974.             if(!(SoapUtils.matchLocalName(messageFactory, trasmissione, "Trasmissione", prefix, SPCoopCostanti.NAMESPACE_EGOV))){
  2975.                 Eccezione ecc = new Eccezione();
  2976.                 ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  2977.                 ecc.setCodiceEccezione(CodiceErroreCooperazione.TRASMISSIONE_NON_PRESENTE);
  2978.                 ecc.setRilevanza(LivelloRilevanza.ERROR);
  2979.                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_TRASMISSIONI_NON_VALIDA_POSIZIONE+"/child["+trasmissione.getNodeName()+"]");
  2980.                 this.erroriValidazione.add(ecc);
  2981.                 continue;
  2982.             }
  2983.             List<Node> childsTrasmissione = SoapUtils.getNotEmptyChildNodes(messageFactory, trasmissione);
  2984.             /*if(childsTrasmissione.getLength() != 3){         
  2985.                 Eccezione ecc = new Eccezione();
  2986.                 ecc.setContestoCodifica(Costanti.CONTESTO_CODIFICA_ECCEZIONE_VALIDAZIONE);
  2987.                 ecc.setCodiceEccezione(Costanti.ECCEZIONE_LISTA_TRASMISSIONI_NON_VALIDA);
  2988.                 ecc.setRilevanza(LivelloRilevanza.GRAVE);
  2989.                 ecc.setDescrizione(Costanti.ECCEZIONE_LISTA_TRASMISSIONI_NON_VALIDA_POSIZIONE_TRASMISSIONE+" child size:"+childsTrasmissione.getLength());
  2990.                 this.erroriValidazione.add(ecc);
  2991.                 continue;
  2992.             }*/

  2994.             boolean presenzaOrigine = false;
  2995.             boolean presenzaDestinazione = false;
  2996.             boolean presenzaOraRegistrazione = false;
  2997.             
  2998.             String origine = null;
  2999.             String tipoOrigine = null;
  3000.             String indTelematicoOrigine = null;
  3001.             boolean findOrigine = false;
  3002.             boolean findTipoOrigine = false;
  3003.             String destinazione = null;
  3004.             String tipoDestinazione = null;
  3005.             String indTelematicoDestinazione = null;
  3006.             boolean findDestinazione = false;
  3007.             boolean findTipoDestinazione = false;
  3008.             String ora = null;
  3009.             Date oraDate = null;
  3010.             boolean findOra = false;
  3011.             String tipoOra = null;
  3012.             boolean findTipoOra = false;
  3013.             for(int j=0; j<childsTrasmissione.size();j++){
  3014.                 Node elem = childsTrasmissione.get(j);

  3016.                 //if(elem.getNodeName().equals(xmlns+"Origine")){
  3017.                 if(SoapUtils.matchLocalName(messageFactory, elem, "Origine", prefix, SPCoopCostanti.NAMESPACE_EGOV)){
  3018.                     
  3019.                     if(presenzaOrigine){
  3020.                         if(this.spcoopProperties.isGenerazioneBustaErrore_strutturaMalformataHeaderProtocollo()==false){
  3021.                             throw new StrutturaBustaException("Header egov con più di un elemento TrasmissioneOrigine","TrasmissioneOrigine");
  3022.                         }else{
  3023.                             Eccezione ecc = new Eccezione();
  3024.                             ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  3025.                             ecc.setCodiceEccezione(CodiceErroreCooperazione.TRASMISSIONE_ORIGINE_PRESENTE_PIU_VOLTE);
  3026.                             ecc.setRilevanza(LivelloRilevanza.ERROR);
  3027.                             if(this.segnalazioneElementoPresentePiuVolte)
  3028.                                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_TRASMISSIONI_NON_VALIDA_POSIZIONE_TRASMISSIONE_ORIGINE+" "+CostantiProtocollo.ECCEZIONE_ELEMENTO_PRESENTE_PIU_VOLTE);
  3029.                             else
  3030.                                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_TRASMISSIONI_NON_VALIDA_POSIZIONE_TRASMISSIONE_ORIGINE.toString());
  3031.                             this.erroriValidazione.add(ecc);
  3032.                             continue;
  3033.                         }
  3034.                     }else{
  3035.                     
  3036.                         presenzaOrigine = true;
  3037.                         
  3038.                         if(SoapUtils.getNotEmptyChildNodes(messageFactory, elem).size() != 1){ 
  3039.                             Eccezione ecc = new Eccezione();
  3040.                             ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  3041.                             ecc.setCodiceEccezione(CodiceErroreCooperazione.TRASMISSIONE_ORIGINE_NON_PRESENTE);
  3042.                             ecc.setRilevanza(LivelloRilevanza.ERROR);
  3043.                             if(SoapUtils.getNotEmptyChildNodes(messageFactory, elem).size() < 1){ 
  3044.                                 if(this.spcoopProperties.isGenerazioneBustaErrore_strutturaMalformataHeaderProtocollo()==false){
  3045.                                     throw new StrutturaBustaException("Header egov senza TrasmissioneOrigine IdentificativoParte","TrasmissioneOrigineIdentificativoParte");
  3046.                                 }else{
  3047.                                     ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_TRASMISSIONI_NON_VALIDA_POSIZIONE_TRASMISSIONE_ORIGINE_IDENTIFICATIVO_PARTE.toString());
  3048.                                 }
  3049.                             }else{
  3050.                                 if(this.segnalazioneElementoPresentePiuVolte)
  3051.                                     ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_TRASMISSIONI_NON_VALIDA_POSIZIONE_TRASMISSIONE_ORIGINE_IDENTIFICATIVO_PARTE+" "+CostantiProtocollo.ECCEZIONE_ELEMENTO_PRESENTE_PIU_VOLTE);
  3052.                                 else
  3053.                                     ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_TRASMISSIONI_NON_VALIDA_POSIZIONE_TRASMISSIONE_ORIGINE_IDENTIFICATIVO_PARTE.toString());
  3054.                             }
  3055.                             this.erroriValidazione.add(ecc);
  3056.                             errorFind = true;
  3057.                             continue;
  3058.                         }
  3059.                         Node idParte = SoapUtils.getNotEmptyChildNodes(messageFactory, elem).get(0);
  3060.                         try{ 
  3061.                             List<Node> valueIDParte = SoapUtils.getNotEmptyChildNodes(messageFactory, idParte);
  3062.                             origine =  valueIDParte.get(0).getNodeValue();
  3063.                             findOrigine = true;
  3064.                         } catch(Exception e) {
  3065.                             Eccezione ecc = new Eccezione();
  3066.                             ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  3067.                             ecc.setCodiceEccezione(CodiceErroreCooperazione.TRASMISSIONE_ORIGINE_NON_VALIDA);
  3068.                             ecc.setRilevanza(LivelloRilevanza.ERROR);
  3069.                             ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_TRASMISSIONI_NON_VALIDA_POSIZIONE_TRASMISSIONE_ORIGINE_IDENTIFICATIVO_PARTE.toString());
  3070.                             this.erroriValidazione.add(ecc);
  3071.                             errorFind = true;
  3072.                         }
  3073.                         try{ 
  3074.                             Node hrefFind = null;
  3075.                             if(this.readQualifiedAttribute){
  3076.                                 hrefFind = SoapUtils.getQualifiedAttributeNode(messageFactory, idParte, "tipo", SPCoopCostanti.NAMESPACE_EGOV);
  3077.                             }else{
  3078.                                 hrefFind = SoapUtils.getAttributeNode(messageFactory, idParte, "tipo");
  3079.                             }
  3080.                             tipoOrigine = hrefFind.getNodeValue();
  3081.                             
  3082.                             // Controllo tipo
  3083.                             if(tipoOrigine==null){
  3084.                                 if(this.spcoopProperties.isGenerazioneBustaErrore_strutturaMalformataHeaderProtocollo()==false){
  3085.                                     if(findTipoOrigine==false){
  3086.                                         throw new StrutturaBustaException("Header egov senza TrasmissioneOrigine IdentificativoParteTipo","TrasmissioneOrigineIdentificativoParteTipo");
  3087.                                     }
  3088.                                 }else{
  3089.                                     throw new Exception("Tipo non definito");
  3090.                                 }
  3091.                             }
  3092.                             try {
  3093.                                 tipoOrigine = this.traduttore.toRegistryOrganizationType(tipoOrigine);
  3094.                             }catch(Exception e) {
  3095.                                 this.log.warn(e.getMessage(),e);
  3096.                                 throw new Exception("Tipo non valido");
  3097.                             }
  3098.                             
  3099.                             findTipoOrigine = true;
  3100.                         } catch (StrutturaBustaException se){
  3101.                             throw se;
  3102.                         } catch(Exception e) {
  3103.                             Eccezione ecc = new Eccezione();
  3104.                             ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  3105.                             ecc.setCodiceEccezione(CodiceErroreCooperazione.TRASMISSIONE_TIPO_ORIGINE_NON_VALIDA);
  3106.                             ecc.setRilevanza(LivelloRilevanza.ERROR);
  3107.                             ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_TRASMISSIONI_NON_VALIDA_POSIZIONE_TRASMISSIONE_ORIGINE_IDENTIFICATIVO_PARTE_TIPO.toString());
  3108.                             this.erroriValidazione.add(ecc);
  3109.                             errorFind = true;
  3110.                         }
  3111.     
  3112.                         // indirizzo Telematico
  3113.                         try{
  3114.                             Node hrefFindT = null;
  3115.                             if(this.readQualifiedAttribute){
  3116.                                 hrefFindT = SoapUtils.getQualifiedAttributeNode(messageFactory, idParte, "indirizzoTelematico", SPCoopCostanti.NAMESPACE_EGOV);
  3117.                             }else{
  3118.                                 hrefFindT = SoapUtils.getAttributeNode(messageFactory, idParte, "indirizzoTelematico");
  3119.                             }
  3120.                             if(hrefFindT != null)
  3121.                                 indTelematicoOrigine = hrefFindT.getNodeValue();
  3122.                             //log.info("IndirizzoTelematicoOrigine ["+indTelematico+"]");
  3123.                         } catch(Exception e) {
  3124.                             Eccezione ecc = new Eccezione();
  3125.                             ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  3126.                             ecc.setCodiceEccezione(CodiceErroreCooperazione.TRASMISSIONE_INDIRIZZO_ORIGINE_NON_VALIDA);
  3127.                             ecc.setRilevanza(LivelloRilevanza.ERROR);
  3128.                             ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_TRASMISSIONI_NON_VALIDA_POSIZIONE_TRASMISSIONE_ORIGINE_IDENTIFICATIVO_PARTE_IND_TELEMATICO.toString());
  3129.                             this.erroriValidazione.add(ecc);
  3130.                             errorFind = true;
  3131.                         }
  3132.                         if(errorFind==false && indTelematicoOrigine != null && (indTelematicoOrigine.equals("")==false)){ 
  3133.                             URL urlcheck = null;
  3134.                             try{    
  3135.                                 urlcheck = new URL( indTelematicoOrigine );
  3136.                                 indTelematicoOrigine = urlcheck.toString();
  3137.                             } catch(Exception e) {
  3138.                                 Eccezione ecc = new Eccezione();
  3139.                                 ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  3140.                                 ecc.setCodiceEccezione(CodiceErroreCooperazione.TRASMISSIONE_INDIRIZZO_ORIGINE_NON_VALIDA);
  3141.                                 ecc.setRilevanza(LivelloRilevanza.ERROR);
  3142.                                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_TRASMISSIONI_NON_VALIDA_POSIZIONE_TRASMISSIONE_ORIGINE_IDENTIFICATIVO_PARTE_IND_TELEMATICO.toString());
  3143.                                 this.erroriValidazione.add(ecc);
  3144.                                 errorFind = true;
  3145.                             }
  3146.                         }
  3147.                     }

  3149.                 //}else if(elem.getNodeName().equals(xmlns+"Destinazione")){
  3150.                 }else if(SoapUtils.matchLocalName(messageFactory, elem, "Destinazione", prefix, SPCoopCostanti.NAMESPACE_EGOV)){

  3152.                     if(presenzaDestinazione){
  3153.                         if(this.spcoopProperties.isGenerazioneBustaErrore_strutturaMalformataHeaderProtocollo()==false){
  3154.                             throw new StrutturaBustaException("Header egov con più di un elemento TrasmissioneDestinazione","TrasmissioneDestinazione");
  3155.                         }else{
  3156.                             Eccezione ecc = new Eccezione();
  3157.                             ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  3158.                             ecc.setCodiceEccezione(CodiceErroreCooperazione.TRASMISSIONE_DESTINAZIONE_PRESENTE_PIU_VOLTE);
  3159.                             ecc.setRilevanza(LivelloRilevanza.ERROR);
  3160.                             if(this.segnalazioneElementoPresentePiuVolte)
  3161.                                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_TRASMISSIONI_NON_VALIDA_POSIZIONE_TRASMISSIONE_DESTINAZIONE+" "+CostantiProtocollo.ECCEZIONE_ELEMENTO_PRESENTE_PIU_VOLTE);
  3162.                             else
  3163.                                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_TRASMISSIONI_NON_VALIDA_POSIZIONE_TRASMISSIONE_DESTINAZIONE.toString());
  3164.                             this.erroriValidazione.add(ecc);
  3165.                             continue;
  3166.                         }
  3167.                     }else{
  3168.                     
  3169.                         presenzaDestinazione = true;
  3170.                     
  3171.                         if(SoapUtils.getNotEmptyChildNodes(messageFactory, elem).size() != 1){ 
  3172.                             Eccezione ecc = new Eccezione();
  3173.                             ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  3174.                             ecc.setCodiceEccezione(CodiceErroreCooperazione.TRASMISSIONE_DESTINAZIONE_NON_VALIDA);
  3175.                             ecc.setRilevanza(LivelloRilevanza.ERROR);
  3176.                             if(SoapUtils.getNotEmptyChildNodes(messageFactory, elem).size() < 1){ 
  3177.                                 if(this.spcoopProperties.isGenerazioneBustaErrore_strutturaMalformataHeaderProtocollo()==false){
  3178.                                     throw new StrutturaBustaException("Header egov senza TrasmissioneDestinazione IdentificativoParte","TrasmissioneDestinazioneIdentificativoParte");
  3179.                                 }else{
  3180.                                     ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_TRASMISSIONI_NON_VALIDA_POSIZIONE_TRASMISSIONE_DESTINAZIONE_IDENTIFICATIVO_PARTE.toString());
  3181.                                 }
  3182.                             }else{
  3183.                                 if(this.segnalazioneElementoPresentePiuVolte)
  3184.                                     ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_TRASMISSIONI_NON_VALIDA_POSIZIONE_TRASMISSIONE_DESTINAZIONE_IDENTIFICATIVO_PARTE+" "+CostantiProtocollo.ECCEZIONE_ELEMENTO_PRESENTE_PIU_VOLTE);
  3185.                                 else
  3186.                                     ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_TRASMISSIONI_NON_VALIDA_POSIZIONE_TRASMISSIONE_DESTINAZIONE_IDENTIFICATIVO_PARTE.toString());
  3187.                             }
  3188.                             this.erroriValidazione.add(ecc);
  3189.                             errorFind = true;
  3190.                             continue;
  3191.                         }
  3192.                         Node idParte = SoapUtils.getNotEmptyChildNodes(messageFactory, elem).get(0);
  3193.                         try{ 
  3194.                             List<Node> valueIDParte = SoapUtils.getNotEmptyChildNodes(messageFactory, idParte);
  3195.                             destinazione =  valueIDParte.get(0).getNodeValue();
  3196.                             findDestinazione = true;
  3197.                         } catch(Exception e) {
  3198.                             Eccezione ecc = new Eccezione();
  3199.                             ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  3200.                             ecc.setCodiceEccezione(CodiceErroreCooperazione.TRASMISSIONE_DESTINAZIONE_NON_VALIDA);
  3201.                             ecc.setRilevanza(LivelloRilevanza.ERROR);
  3202.                             ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_TRASMISSIONI_NON_VALIDA_POSIZIONE_TRASMISSIONE_DESTINAZIONE_IDENTIFICATIVO_PARTE.toString());
  3203.                             this.erroriValidazione.add(ecc);
  3204.                             errorFind = true;
  3205.                         }
  3206.                         try{ 
  3207.                             Node hrefFind = null;
  3208.                             if(this.readQualifiedAttribute){
  3209.                                 hrefFind = SoapUtils.getQualifiedAttributeNode(messageFactory, idParte, "tipo", SPCoopCostanti.NAMESPACE_EGOV);
  3210.                             }else{
  3211.                                 hrefFind = SoapUtils.getAttributeNode(messageFactory, idParte, "tipo");
  3212.                             }
  3213.                             tipoDestinazione = hrefFind.getNodeValue();
  3214.                             
  3215.                             // Controllo tipo
  3216.                             if(tipoDestinazione==null){
  3217.                                 if(this.spcoopProperties.isGenerazioneBustaErrore_strutturaMalformataHeaderProtocollo()==false){
  3218.                                     if(findTipoOrigine==false){
  3219.                                         throw new StrutturaBustaException("Header egov senza TrasmissioneDestinazione IdentificativoParteTipo","TrasmissioneDestinazioneIdentificativoParteTipo");
  3220.                                     }
  3221.                                 }else{
  3222.                                     throw new Exception("Tipo non definito");
  3223.                                 }
  3224.                             }
  3225.                             try {
  3226.                                 tipoDestinazione = this.traduttore.toRegistryOrganizationType(tipoDestinazione);
  3227.                             }catch(Exception e) {
  3228.                                 this.log.warn(e.getMessage(),e);
  3229.                                 throw new Exception("Tipo non valido");
  3230.                             }
  3231.                             
  3232.                             findTipoDestinazione = true;
  3233.                         } catch (StrutturaBustaException se){
  3234.                             throw se;
  3235.                         } catch(Exception e) {
  3236.                             Eccezione ecc = new Eccezione();
  3237.                             ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  3238.                             ecc.setCodiceEccezione(CodiceErroreCooperazione.TRASMISSIONE_TIPO_DESTINAZIONE_NON_VALIDA);
  3239.                             ecc.setRilevanza(LivelloRilevanza.ERROR);
  3240.                             ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_TRASMISSIONI_NON_VALIDA_POSIZIONE_TRASMISSIONE_DESTINAZIONE_IDENTIFICATIVO_PARTE_TIPO.toString());
  3241.                             this.erroriValidazione.add(ecc);
  3242.                             errorFind = true;
  3243.                         }
  3244.     
  3245.                         // indirizzo Telematico
  3246.                         try{
  3247.                             Node hrefFindT = null;
  3248.                             if(this.readQualifiedAttribute){
  3249.                                 hrefFindT = SoapUtils.getQualifiedAttributeNode(messageFactory, idParte, "indirizzoTelematico", SPCoopCostanti.NAMESPACE_EGOV);
  3250.                             }else{
  3251.                                 hrefFindT = SoapUtils.getAttributeNode(messageFactory, idParte, "indirizzoTelematico");
  3252.                             }
  3253.                             if(hrefFindT != null)
  3254.                                 indTelematicoDestinazione = hrefFindT.getNodeValue();
  3255.                             //log.info("IndirizzoTelematicoDestinazione ["+indTelematico+"]");
  3256.                         } catch(Exception e) {
  3257.                             Eccezione ecc = new Eccezione();
  3258.                             ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  3259.                             ecc.setCodiceEccezione(CodiceErroreCooperazione.TRASMISSIONE_INDIRIZZO_DESTINAZIONE_NON_VALIDA);
  3260.                             ecc.setRilevanza(LivelloRilevanza.ERROR);
  3261.                             ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_TRASMISSIONI_NON_VALIDA_POSIZIONE_TRASMISSIONE_DESTINAZIONE_IDENTIFICATIVO_PARTE_IND_TELEMATICO.toString());
  3262.                             this.erroriValidazione.add(ecc);
  3263.                             errorFind = true;
  3264.                         }
  3265.                         if(errorFind==false && indTelematicoDestinazione != null && (indTelematicoDestinazione.equals("")==false)){ 
  3266.                             URL urlcheck = null;
  3267.                             try{    
  3268.                                 urlcheck = new URL( indTelematicoDestinazione );
  3269.                                 indTelematicoDestinazione = urlcheck.toString();
  3270.                             } catch(Exception e) {
  3271.                                 Eccezione ecc = new Eccezione();
  3272.                                 ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  3273.                                 ecc.setCodiceEccezione(CodiceErroreCooperazione.TRASMISSIONE_INDIRIZZO_DESTINAZIONE_NON_VALIDA);
  3274.                                 ecc.setRilevanza(LivelloRilevanza.ERROR);
  3275.                                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_TRASMISSIONI_NON_VALIDA_POSIZIONE_TRASMISSIONE_DESTINAZIONE_IDENTIFICATIVO_PARTE_IND_TELEMATICO.toString());
  3276.                                 this.erroriValidazione.add(ecc);
  3277.                                 errorFind = true;
  3278.                             }
  3279.                         }
  3280.                     }

  3282.                 //}else if(elem.getNodeName().equals(xmlns+"OraRegistrazione")){
  3283.                 }else if(SoapUtils.matchLocalName(messageFactory, elem, "OraRegistrazione", prefix, SPCoopCostanti.NAMESPACE_EGOV)){

  3285.                     if(presenzaOraRegistrazione){
  3286.                         if(this.spcoopProperties.isGenerazioneBustaErrore_strutturaMalformataHeaderProtocollo()==false){
  3287.                             throw new StrutturaBustaException("Header egov con più di un elemento TrasmissioneOraRegistrazione","TrasmissioneOraRegistrazione");
  3288.                         }else{
  3289.                             Eccezione ecc = new Eccezione();
  3290.                             ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  3291.                             ecc.setCodiceEccezione(CodiceErroreCooperazione.TRASMISSIONE_ORA_REGISTRAZIONE_PRESENTE_PIU_VOLTE);
  3292.                             ecc.setRilevanza(LivelloRilevanza.ERROR);
  3293.                             if(this.segnalazioneElementoPresentePiuVolte)
  3294.                                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_TRASMISSIONI_NON_VALIDA_POSIZIONE_TRASMISSIONE_ORA_REGISTRAZIONE+" "+CostantiProtocollo.ECCEZIONE_ELEMENTO_PRESENTE_PIU_VOLTE);
  3295.                             else
  3296.                                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_TRASMISSIONI_NON_VALIDA_POSIZIONE_TRASMISSIONE_ORA_REGISTRAZIONE.toString());
  3297.                             this.erroriValidazione.add(ecc);
  3298.                             continue;
  3299.                         }
  3300.                     }else{
  3301.                     
  3302.                         presenzaOraRegistrazione = true;
  3303.                     
  3304.                         // ora ...
  3305.                         try{
  3306.                             ora = SoapUtils.getNotEmptyChildNodes(messageFactory, elem).get(0).getNodeValue();
  3307.                             findOra = true;
  3308.                         } catch(Exception e) {
  3309.                             Eccezione ecc = new Eccezione();
  3310.                             ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  3311.                             ecc.setCodiceEccezione(CodiceErroreCooperazione.TRASMISSIONE_ORA_REGISTRAZIONE_NON_VALIDA);
  3312.                             ecc.setRilevanza(LivelloRilevanza.ERROR);
  3313.                             ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_TRASMISSIONI_NON_VALIDA_POSIZIONE_TRASMISSIONE_ORA_REGISTRAZIONE.toString());
  3314.                             this.erroriValidazione.add(ecc);
  3315.                             errorFind = true;
  3316.                         }
  3317.                         oraDate = null;
  3318.                         if(ora != null)
  3319.                             oraDate = validazioneData(ora);
  3320.                         if( (ora == null) || (oraDate == null)){
  3321.                             Eccezione ecc = new Eccezione();
  3322.                             ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  3323.                             ecc.setCodiceEccezione(CodiceErroreCooperazione.TRASMISSIONE_ORA_REGISTRAZIONE_NON_VALIDA);
  3324.                             ecc.setRilevanza(LivelloRilevanza.ERROR);
  3325.                             ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_TRASMISSIONI_NON_VALIDA_POSIZIONE_TRASMISSIONE_ORA_REGISTRAZIONE.toString());
  3326.                             this.erroriValidazione.add(ecc);
  3327.                             errorFind = true;
  3328.                         }
  3329.     
  3330.                         // tempo ...
  3331.                         try{
  3332.                             Node hrefFind = null;
  3333.                             if(this.readQualifiedAttribute){
  3334.                                 hrefFind = SoapUtils.getQualifiedAttributeNode(messageFactory, elem, "tempo", SPCoopCostanti.NAMESPACE_EGOV);
  3335.                             }else{
  3336.                                 hrefFind = SoapUtils.getAttributeNode(messageFactory, elem, "tempo");
  3337.                             }
  3338.                             tipoOra = hrefFind.getNodeValue();
  3339.                             findTipoOra = true;
  3340.                         } catch(Exception e) {
  3341.                             if(this.spcoopProperties.isGenerazioneBustaErrore_strutturaMalformataHeaderProtocollo()==false){
  3342.                                 if(findTipoOrigine==false){
  3343.                                     throw new StrutturaBustaException("Header egov senza Trasmissione OraRegistrazioneTempo","TrasmissioneOraRegistrazioneTempo");
  3344.                                 }
  3345.                             }else{
  3346.                                 Eccezione ecc = new Eccezione();
  3347.                                 ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  3348.                                 ecc.setCodiceEccezione(CodiceErroreCooperazione.TRASMISSIONE_TIPO_ORA_REGISTRAZIONE_NON_VALIDA);
  3349.                                 ecc.setRilevanza(LivelloRilevanza.ERROR);
  3350.                                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_TRASMISSIONI_NON_VALIDA_POSIZIONE_TRASMISSIONE_ORA_REGISTRAZIONE_TEMPO.toString());
  3351.                                 this.erroriValidazione.add(ecc);
  3352.                                 errorFind = true;
  3353.                             }
  3354.                         }
  3355.                         if(tipoOra!=null){
  3356.                             if(!tipoOra.equals(SPCoopCostanti.TIPO_TEMPO_LOCALE) && !tipoOra.equals(SPCoopCostanti.TIPO_TEMPO_SPC)){
  3357.                                 Eccezione ecc = new Eccezione();
  3358.                                 ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  3359.                                 ecc.setCodiceEccezione(CodiceErroreCooperazione.TRASMISSIONE_TIPO_ORA_REGISTRAZIONE_SCONOSCIUTA);
  3360.                                 ecc.setRilevanza(LivelloRilevanza.ERROR);
  3361.                                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_TRASMISSIONI_NON_VALIDA_POSIZIONE_TRASMISSIONE_ORA_REGISTRAZIONE_TEMPO.toString());
  3362.                                 this.erroriValidazione.add(ecc);
  3363.                                 errorFind = true;
  3364.                             }
  3365.                         }
  3366.                     }
  3367.                 }else {
  3368.                     Eccezione ecc = new Eccezione();
  3369.                     ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  3370.                     ecc.setCodiceEccezione(CodiceErroreCooperazione.LISTA_TRASMISSIONI_NON_VALIDA);
  3371.                     ecc.setRilevanza(LivelloRilevanza.ERROR);
  3372.                     ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_TRASMISSIONI_NON_VALIDA_POSIZIONE_TRASMISSIONE+"/child["+elem.getNodeName()+"]");
  3373.                     this.erroriValidazione.add(ecc);
  3374.                     errorFind = true;
  3375.                 }

  3377.             }
  3378.             
  3379.             
  3380.             // Check elementi principali
  3381.             if(this.spcoopProperties.isGenerazioneBustaErrore_strutturaMalformataHeaderProtocollo()==false){
  3382.                 if(presenzaOrigine==false){
  3383.                     throw new StrutturaBustaException("Header egov senza TrasmissioneOrigine","TrasmissioneOrigine");
  3384.                 }
  3385.                 if(presenzaDestinazione==false){
  3386.                     throw new StrutturaBustaException("Header egov senza TrasmissioneDestinazione","TrasmissioneDestinazione");
  3387.                 }
  3388.                 if(presenzaOraRegistrazione==false){
  3389.                     throw new StrutturaBustaException("Header egov senza TrasmissioneOraRegistrazione","TrasmissioneOraRegistrazione");
  3390.                 }
  3391.             }
  3392.             
  3393.             if(errorFind == false){
  3394.                 if(presenzaOrigine==false){
  3395.                     errorFind = true;
  3396.                     Eccezione ecc = new Eccezione();
  3397.                     ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  3398.                     ecc.setCodiceEccezione(CodiceErroreCooperazione.TRASMISSIONE_ORIGINE_NON_PRESENTE);
  3399.                     ecc.setRilevanza(LivelloRilevanza.ERROR);
  3400.                     ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_TRASMISSIONI_NON_VALIDA_POSIZIONE_TRASMISSIONE_ORIGINE.toString());
  3401.                     this.erroriValidazione.add(ecc);
  3402.                 }
  3403.                 if(presenzaDestinazione==false){
  3404.                     errorFind = true;
  3405.                     Eccezione ecc = new Eccezione();
  3406.                     ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  3407.                     ecc.setCodiceEccezione(CodiceErroreCooperazione.TRASMISSIONE_DESTINAZIONE_NON_PRESENTE);
  3408.                     ecc.setRilevanza(LivelloRilevanza.ERROR);
  3409.                     ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_TRASMISSIONI_NON_VALIDA_POSIZIONE_TRASMISSIONE_DESTINAZIONE.toString());
  3410.                     this.erroriValidazione.add(ecc);
  3411.                 }
  3412.                 if(presenzaOraRegistrazione==false){
  3413.                     errorFind = true;
  3414.                     Eccezione ecc = new Eccezione();
  3415.                     ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  3416.                     ecc.setCodiceEccezione(CodiceErroreCooperazione.TRASMISSIONE_ORA_REGISTRAZIONE_NON_PRESENTE);
  3417.                     ecc.setRilevanza(LivelloRilevanza.ERROR);
  3418.                     ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_TRASMISSIONI_NON_VALIDA_POSIZIONE_TRASMISSIONE_ORA_REGISTRAZIONE.toString());
  3419.                     this.erroriValidazione.add(ecc);
  3420.                 }
  3421.             }
  3422.             
  3423.             if(errorFind == false){
  3424.                 if(findOrigine != true){
  3425.                     Eccezione ecc = new Eccezione();
  3426.                     ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  3427.                     ecc.setCodiceEccezione(CodiceErroreCooperazione.TRASMISSIONE_ORIGINE_NON_PRESENTE);
  3428.                     ecc.setRilevanza(LivelloRilevanza.ERROR);
  3429.                     ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_TRASMISSIONI_NON_VALIDA_POSIZIONE_TRASMISSIONE_ORIGINE_IDENTIFICATIVO_PARTE.toString());
  3430.                     this.erroriValidazione.add(ecc);
  3431.                 }else{
  3432.                     if(findTipoOrigine != true){
  3433.                         Eccezione ecc = new Eccezione();
  3434.                         ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  3435.                         ecc.setCodiceEccezione(CodiceErroreCooperazione.TRASMISSIONE_TIPO_ORIGINE_NON_PRESENTE);
  3436.                         ecc.setRilevanza(LivelloRilevanza.ERROR);
  3437.                         ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_TRASMISSIONI_NON_VALIDA_POSIZIONE_TRASMISSIONE_ORIGINE_IDENTIFICATIVO_PARTE_TIPO.toString());
  3438.                         this.erroriValidazione.add(ecc);
  3439.                     }
  3440.                 }
  3441.                 if(findDestinazione != true){
  3442.                     Eccezione ecc = new Eccezione();
  3443.                     ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  3444.                     ecc.setCodiceEccezione(CodiceErroreCooperazione.TRASMISSIONE_DESTINAZIONE_NON_PRESENTE);
  3445.                     ecc.setRilevanza(LivelloRilevanza.ERROR);
  3446.                     ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_TRASMISSIONI_NON_VALIDA_POSIZIONE_TRASMISSIONE_DESTINAZIONE_IDENTIFICATIVO_PARTE.toString());
  3447.                     this.erroriValidazione.add(ecc);
  3448.                 }else{
  3449.                     if(findTipoDestinazione != true){
  3450.                         Eccezione ecc = new Eccezione();
  3451.                         ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  3452.                         ecc.setCodiceEccezione(CodiceErroreCooperazione.TRASMISSIONE_TIPO_DESTINAZIONE_NON_PRESENTE);
  3453.                         ecc.setRilevanza(LivelloRilevanza.ERROR);
  3454.                         ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_TRASMISSIONI_NON_VALIDA_POSIZIONE_TRASMISSIONE_DESTINAZIONE_IDENTIFICATIVO_PARTE_TIPO.toString());
  3455.                         this.erroriValidazione.add(ecc);
  3456.                     }
  3457.                 }
  3458.                 if(findOra != true){
  3459.                     Eccezione ecc = new Eccezione();
  3460.                     ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  3461.                     ecc.setCodiceEccezione(CodiceErroreCooperazione.TRASMISSIONE_ORA_REGISTRAZIONE_NON_PRESENTE);
  3462.                     ecc.setRilevanza(LivelloRilevanza.ERROR);
  3463.                     ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_TRASMISSIONI_NON_VALIDA_POSIZIONE_TRASMISSIONE_ORA_REGISTRAZIONE.toString());
  3464.                     this.erroriValidazione.add(ecc);
  3465.                 }else{
  3466.                     if(findTipoOra != true){
  3467.                         Eccezione ecc = new Eccezione();
  3468.                         ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  3469.                         ecc.setCodiceEccezione(CodiceErroreCooperazione.TRASMISSIONE_TIPO_ORA_REGISTRAZIONE_NON_PRESENTE);
  3470.                         ecc.setRilevanza(LivelloRilevanza.ERROR);
  3471.                         ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_TRASMISSIONI_NON_VALIDA_POSIZIONE_TRASMISSIONE_ORA_REGISTRAZIONE_TEMPO.toString());
  3472.                         this.erroriValidazione.add(ecc);
  3473.                     }
  3474.                 }
  3475.             }
  3476.             
  3477.             //if(origine!=null && tipoOrigine!=null && tipoDestinazione!=null && destinazione!=null && 
  3478.             //      ora!=null && tipoOra != null) {
  3479.             if(origine!=null || tipoOrigine!=null || tipoDestinazione!=null || destinazione!=null || 
  3480.                     ora!=null || tipoOra != null) {
  3481.                 //log.info("add Trasmissione....");
  3482.                 Trasmissione tr = new Trasmissione();
  3483.                 tr.setOrigine(origine);
  3484.                 tr.setTipoOrigine(tipoOrigine);
  3485.                 tr.setIndirizzoOrigine(indTelematicoOrigine);
  3486.                 tr.setDestinazione(destinazione);
  3487.                 tr.setTipoDestinazione(tipoDestinazione);
  3488.                 tr.setIndirizzoDestinazione(indTelematicoDestinazione);
  3489.                 //log.info("ORA REC["+oraDate+"]");
  3490.                 tr.setOraRegistrazione(oraDate);
  3491.                 tr.setTempoValue(tipoOra);
  3492.                 tr.setTempo(this.traduttore.toTipoOraRegistrazione(tipoOra));
  3493.                 this.busta.addTrasmissione(tr);
  3494.             }
  3495.         }

  3497.     }

  3499.     /**
  3500.      * Metodo che si occupa di validare la lista Eccezioni <var>child</var> secondo specifica eGov.
  3501.      * <p>
  3502.      * Il metodo, oltre ad effettuare la validazione, si occupa anche di leggerne il contenuto e 
  3503.      * di impostarlo all'interno dell'oggetto <var>busta</var>.
  3504.      * Mano mano che sono incontrati errori di validazione, viene creato un oggetto 
  3505.      *    {@link Eccezione}, e viene inserito in un errorsEccezione.
  3506.      *
  3507.      * @param child nodo su cui effettuare la validazione
  3508.      * @throws ProtocolException 
  3509.      * 
  3510.      */
  3511.     private void validazioneListaEccezioni(OpenSPCoop2MessageFactory messageFactory, Node child,String prefix) throws StrutturaBustaException, ProtocolException{

  3513.         //log.info("Validazione Lista Eccezioni...");
  3514.         List<Node> eccezioni = SoapUtils.getNotEmptyChildNodes(messageFactory, child);

  3516.         for(int i=0; i<eccezioni.size();i++){

  3518.             boolean errorFind = false;

  3520.             Node eccezione = eccezioni.get(i);
  3521.             //log.info("esamino["+child.getNodeName()+"]");
  3522.             //if(!(eccezione.getNodeName().equals(xmlns+"Eccezione"))){
  3523.             if(!(SoapUtils.matchLocalName(messageFactory, eccezione, "Eccezione", prefix, SPCoopCostanti.NAMESPACE_EGOV))){
  3524.                 Eccezione ecc = new Eccezione();
  3525.                 ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  3526.                 ecc.setCodiceEccezione(CodiceErroreCooperazione.INTESTAZIONE_NON_CORRETTA);
  3527.                 ecc.setRilevanza(LivelloRilevanza.ERROR);
  3528.                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_ECCEZIONI_NON_VALIDA_POSIZIONE+"/child["+eccezione.getNodeName()+"]");
  3529.                 this.errorsTrovatiSullaListaEccezioni.add(ecc);
  3530.                 errorFind = true;
  3531.             }

  3533.             String contestoCodifica = null;
  3534.             String codiceEccezione = null;
  3535.             String rilevanza = null;
  3536.             String posizione = null;
  3537.             

  3539.             // ContestoCodifica
  3540.             boolean contestoCodificaError = false;
  3541.             try{
  3542.                 Node hrefFind = null;
  3543.                 if(this.readQualifiedAttribute){
  3544.                     hrefFind = SoapUtils.getQualifiedAttributeNode(messageFactory, eccezione, "contestoCodifica", SPCoopCostanti.NAMESPACE_EGOV);
  3545.                 }else{
  3546.                     hrefFind = SoapUtils.getAttributeNode(messageFactory, eccezione, "contestoCodifica");
  3547.                 }
  3548.                 contestoCodifica = hrefFind.getNodeValue();
  3549.             } catch(Exception e) {
  3550.                 contestoCodificaError = true;
  3551.             }
  3552.             if(contestoCodifica == null)
  3553.                 contestoCodificaError = true;
  3554.             if(contestoCodificaError){
  3555.                 Eccezione ecc = new Eccezione();
  3556.                 ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  3557.                 ecc.setCodiceEccezione(CodiceErroreCooperazione.INTESTAZIONE_NON_CORRETTA);
  3558.                 ecc.setRilevanza(LivelloRilevanza.ERROR);
  3559.                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_ECCEZIONI_NON_VALIDA_POSIZIONE_CONTESTO_CODIFICA.toString());
  3560.                 this.errorsTrovatiSullaListaEccezioni.add(ecc);
  3561.                 errorFind = true;
  3562.             }

  3564.             // codiceEccezione
  3565.             boolean codiceEccezioneError = false;
  3566.             try{
  3567.                 Node hrefFind = null;
  3568.                 if(this.readQualifiedAttribute){
  3569.                     hrefFind = SoapUtils.getQualifiedAttributeNode(messageFactory, eccezione, "codiceEccezione", SPCoopCostanti.NAMESPACE_EGOV);
  3570.                 }else{
  3571.                     hrefFind = SoapUtils.getAttributeNode(messageFactory, eccezione, "codiceEccezione");
  3572.                 }
  3573.                 codiceEccezione = hrefFind.getNodeValue();
  3574.             } catch(Exception e) {
  3575.                 codiceEccezioneError = true;
  3576.             }
  3577.             if(validazioneCodiceEccezione(codiceEccezione) == false)
  3578.                 codiceEccezioneError = true;
  3579.             if(codiceEccezioneError){
  3580.                 Eccezione ecc = new Eccezione();
  3581.                 ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  3582.                 ecc.setCodiceEccezione(CodiceErroreCooperazione.INTESTAZIONE_NON_CORRETTA);
  3583.                 ecc.setRilevanza(LivelloRilevanza.ERROR);
  3584.                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_ECCEZIONI_NON_VALIDA_POSIZIONE_CODICE_ECCEZIONE.toString());
  3585.                 this.errorsTrovatiSullaListaEccezioni.add(ecc);
  3586.                 errorFind = true;
  3587.             }

  3589.             // Rilevanza
  3590.             boolean rilevanzaError = false;
  3591.             try{
  3592.                 Node hrefFind = null;
  3593.                 if(this.readQualifiedAttribute){
  3594.                     hrefFind = SoapUtils.getQualifiedAttributeNode(messageFactory, eccezione, "rilevanza", SPCoopCostanti.NAMESPACE_EGOV);
  3595.                 }else{
  3596.                     hrefFind = SoapUtils.getAttributeNode(messageFactory, eccezione, "rilevanza");
  3597.                 }
  3598.                 rilevanza = hrefFind.getNodeValue();
  3599.             } catch(Exception e) {
  3600.                 rilevanzaError = true;
  3601.             }
  3602.             LivelloRilevanza livRilevanza = validazioneRilevanza(rilevanza);
  3603.             if(livRilevanza.equals(LivelloRilevanza.UNKNOWN))
  3604.                 rilevanzaError = true;
  3605.             if(rilevanzaError){
  3606.                 Eccezione ecc = new Eccezione();
  3607.                 ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  3608.                 ecc.setCodiceEccezione(CodiceErroreCooperazione.INTESTAZIONE_NON_CORRETTA);
  3609.                 ecc.setRilevanza(LivelloRilevanza.ERROR);
  3610.                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_ECCEZIONI_NON_VALIDA_POSIZIONE_RILEVANZA.toString());
  3611.                 this.errorsTrovatiSullaListaEccezioni.add(ecc);
  3612.                 errorFind = true;
  3613.             }

  3615.             // Posizione
  3616.             boolean posizioneError = false;
  3617.             try{
  3618.                 Node hrefFind = null;
  3619.                 if(this.readQualifiedAttribute){
  3620.                     hrefFind = SoapUtils.getQualifiedAttributeNode(messageFactory, eccezione, "posizione", SPCoopCostanti.NAMESPACE_EGOV);
  3621.                 }else{
  3622.                     hrefFind = SoapUtils.getAttributeNode(messageFactory, eccezione, "posizione");
  3623.                 }
  3624.                 posizione = hrefFind.getNodeValue();
  3625.             } catch(Exception e) {
  3626.                 posizioneError = true;
  3627.             }
  3628.             if(posizione == null)
  3629.                 posizioneError = true;
  3630.             if(posizioneError){
  3631.                 Eccezione ecc = new Eccezione();
  3632.                 ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  3633.                 ecc.setCodiceEccezione(CodiceErroreCooperazione.INTESTAZIONE_NON_CORRETTA);
  3634.                 ecc.setRilevanza(LivelloRilevanza.ERROR);
  3635.                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_ECCEZIONI_NON_VALIDA_POSIZIONE_POSIZIONE.toString());
  3636.                 this.errorsTrovatiSullaListaEccezioni.add(ecc);
  3637.                 errorFind = true;
  3638.             }

  3640.             if(this.spcoopProperties.isGenerazioneBustaErrore_strutturaMalformataHeaderProtocollo()==false){
  3641.                 if(contestoCodifica == null){
  3642.                     throw new StrutturaBustaException("Header egov senza Eccezione contestoCodifica","EccezioneContestoCodifica");
  3643.                 }
  3644.                 if(codiceEccezione == null){
  3645.                     throw new StrutturaBustaException("Header egov senza Eccezione codiceEccezione","EccezioneCodiceEccezione");
  3646.                 }
  3647.                 if(rilevanza == null){
  3648.                     throw new StrutturaBustaException("Header egov senza Eccezione rilevanza","EccezioneRilevanza");
  3649.                 }
  3650.                 if(posizione == null){
  3651.                     throw new StrutturaBustaException("Header egov senza Eccezione posizione","EccezionePosizione");
  3652.                 }
  3653.             }
  3654.             
  3655.             // Check finale
  3656.             if(errorFind == false){
  3657.                 if(contestoCodifica == null){
  3658.                     Eccezione ecc = new Eccezione();
  3659.                     ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  3660.                     ecc.setCodiceEccezione(CodiceErroreCooperazione.INTESTAZIONE_NON_CORRETTA);
  3661.                     ecc.setRilevanza(LivelloRilevanza.ERROR);
  3662.                     ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_ECCEZIONI_NON_VALIDA_POSIZIONE_CONTESTO_CODIFICA.toString());
  3663.                     this.errorsTrovatiSullaListaEccezioni.add(ecc);
  3664.                 }
  3665.                 if(codiceEccezione == null){
  3666.                     Eccezione ecc = new Eccezione();
  3667.                     ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  3668.                     ecc.setCodiceEccezione(CodiceErroreCooperazione.INTESTAZIONE_NON_CORRETTA);
  3669.                     ecc.setRilevanza(LivelloRilevanza.ERROR);
  3670.                     ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_ECCEZIONI_NON_VALIDA_POSIZIONE_CODICE_ECCEZIONE.toString());
  3671.                     this.errorsTrovatiSullaListaEccezioni.add(ecc);
  3672.                 }
  3673.                 if(rilevanza == null){
  3674.                     Eccezione ecc = new Eccezione();
  3675.                     ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  3676.                     ecc.setCodiceEccezione(CodiceErroreCooperazione.INTESTAZIONE_NON_CORRETTA);
  3677.                     ecc.setRilevanza(LivelloRilevanza.ERROR);
  3678.                     ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_ECCEZIONI_NON_VALIDA_POSIZIONE_RILEVANZA.toString());
  3679.                     this.errorsTrovatiSullaListaEccezioni.add(ecc);
  3680.                 }
  3681.                 if(posizione == null){
  3682.                     Eccezione ecc = new Eccezione();
  3683.                     ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  3684.                     ecc.setCodiceEccezione(CodiceErroreCooperazione.INTESTAZIONE_NON_CORRETTA);
  3685.                     ecc.setRilevanza(LivelloRilevanza.ERROR);
  3686.                     ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_ECCEZIONI_NON_VALIDA_POSIZIONE_POSIZIONE.toString());
  3687.                     this.errorsTrovatiSullaListaEccezioni.add(ecc);
  3688.                 }
  3689.             }
  3690.             
  3691.             if(contestoCodifica!=null && codiceEccezione!=null && rilevanza !=null && posizione!=null) {
  3692.                 Eccezione eccLetta = new Eccezione();
  3693.                 
  3694.                 eccLetta.setContestoCodificaValue(contestoCodifica);
  3695.                 eccLetta.setContestoCodifica(this.traduttore.toContestoCodificaEccezione(contestoCodifica));
  3696.                 
  3697.                 eccLetta.setCodiceEccezioneValue(codiceEccezione);
  3698.                 eccLetta.setCodiceEccezione(this.traduttore.toCodiceErroreCooperazione(codiceEccezione));
  3699.                                 
  3700.                 eccLetta.setRilevanza(livRilevanza);
  3701.                 eccLetta.setRilevanzaValue(rilevanza);
  3702.                 
  3703.                 eccLetta.setDescrizione(posizione);
  3704.                 
  3705.                 this.busta.addEccezione(eccLetta);
  3706.             }
  3707.         }

  3709.     }

  3711.     /**
  3712.      * Metodo che si occupa di validare un codice di rilevanza associato ad una Eccezione. 
  3713.      *
  3714.      * @param codice Codice della rilevanza da validare.
  3715.      * @return true se il codice e' valido, false altrimenti
  3716.      * @throws ProtocolException 
  3717.      * 
  3718.      */
  3719.     private LivelloRilevanza validazioneRilevanza(String codice) throws ProtocolException{
  3720.         return this.traduttore.toLivelloRilevanza(codice);
  3721.     }

  3723.     /**
  3724.      * Metodo che si occupa di validare un codice di errore associato ad una Eccezione. 
  3725.      *
  3726.      * @param codice Codice dell'eccezione da validare.
  3727.      * @return true se il codice e' valido, false altrimenti
  3728.      * 
  3729.      */

  3731.     public boolean validazioneCodiceEccezione(CodiceErroreCooperazione codice){
  3732.         String v = this.traduttore.toString(codice);
  3733.         return v!=null;
  3734.     }
  3735.     
  3736.     public boolean validazioneCodiceEccezione(String codicetxt) throws ProtocolException{
  3737.         CodiceErroreCooperazione codice = CodiceErroreCooperazione.toCodiceErroreCooperazione(this.protocolFactory, codicetxt);
  3738.         return validazioneCodiceEccezione(codice);
  3739.     }


  3742.     public void validazioneFaultEGov(OpenSPCoop2Message msg){

  3744.         try{
  3745.             SOAPBody body = msg.castAsSoap().getSOAPBody();
  3746.             
  3747.             //Traduttore trasl = this.protocolFactory.createTraduttore();

  3749.             //log.info("VALIDAZIONE FAULT");
  3750.             if(body.hasFault() == false){
  3751.                 Eccezione ecc = new Eccezione();
  3752.                 ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  3753.                 ecc.setCodiceEccezione(CodiceErroreCooperazione.FORMATO_CORPO_NON_CORRETTO);
  3754.                 ecc.setRilevanza(LivelloRilevanza.ERROR);
  3755.                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_ECCEZIONI_NON_VALIDA_POSIZIONE_SOAP_FAULT.toString());
  3756.                 this.errorsTrovatiSullaListaEccezioni.add(ecc);
  3757.             } else {
  3758.                 SOAPFault fault = body.getFault();
  3759.                 boolean valoriOK = true;

  3761.                 // Controllo sul Fault
  3762.                 String faultS = fault.getFaultString();
  3763.                 if(faultS!=null)
  3764.                     faultS = faultS.trim();
  3765.                 if( !(SPCoopCostanti.FAULT_STRING_PROCESSAMENTO.equals(faultS)) && 
  3766.                         !(SPCoopCostanti.FAULT_STRING_VALIDAZIONE.equals(faultS))  ){
  3767.                     Eccezione ecc = new Eccezione();
  3768.                     ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  3769.                     ecc.setCodiceEccezione(CodiceErroreCooperazione.FORMATO_CORPO_NON_CORRETTO);
  3770.                     ecc.setRilevanza(LivelloRilevanza.ERROR);
  3771.                     ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_ECCEZIONI_NON_VALIDA_POSIZIONE_SOAP_FAULT_STRING.toString());
  3772.                     this.errorsTrovatiSullaListaEccezioni.add(ecc);
  3773.                     valoriOK = false;
  3774.                 }
  3775.                 Name codeS = fault.getFaultCodeAsName();
  3776.                 
  3777.                 if( 
  3778.                         (codeS == null) 
  3779.                         ||
  3780.                         !(
  3781.                                 ("Client".equals(codeS.getLocalName()) || "Server".equals(codeS.getLocalName()) ) && 
  3782.                                 Costanti.SOAP_ENVELOPE_NAMESPACE.equalsIgnoreCase(codeS.getURI()) 
  3783.                         )
  3784.                 )
  3785.                 {
  3786.                     Eccezione ecc = new Eccezione();
  3787.                     ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  3788.                     ecc.setCodiceEccezione(CodiceErroreCooperazione.FORMATO_CORPO_NON_CORRETTO);
  3789.                     ecc.setRilevanza(LivelloRilevanza.ERROR);
  3790.                     ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_ECCEZIONI_NON_VALIDA_POSIZIONE_SOAP_FAULT_CODE.toString());
  3791.                     this.errorsTrovatiSullaListaEccezioni.add(ecc);
  3792.                     valoriOK = false;
  3793.                 }
  3794.                 if(valoriOK){
  3795.                     if ("Client".equals(codeS.getLocalName()) ){
  3796.                         boolean detailPresente = false;
  3797.                         Detail d = fault.getDetail();
  3798.                         if(d!=null){
  3799.                             if(d.getDetailEntries().hasNext())
  3800.                                 detailPresente = true;
  3801.                         }   
  3802.                         // Con soap:Client, non ci deveno essere Detail, e ci deve essere FAULT_STRING_VALIDAZIONE_SPCOOP!
  3803.                         if ( !(SPCoopCostanti.FAULT_STRING_VALIDAZIONE.equals(faultS)) ) {
  3804.                             Eccezione ecc = new Eccezione();
  3805.                             ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  3806.                             ecc.setCodiceEccezione(CodiceErroreCooperazione.FORMATO_CORPO_NON_CORRETTO);
  3807.                             ecc.setRilevanza(LivelloRilevanza.ERROR);
  3808.                             ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_ECCEZIONI_NON_VALIDA_POSIZIONE_SOAP_FAULT_STRING.toString());
  3809.                             this.errorsTrovatiSullaListaEccezioni.add(ecc);
  3810.                         }
  3811.                         if (detailPresente) {
  3812.                             Eccezione ecc = new Eccezione();
  3813.                             ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  3814.                             ecc.setCodiceEccezione(CodiceErroreCooperazione.FORMATO_CORPO_NON_CORRETTO);
  3815.                             ecc.setRilevanza(LivelloRilevanza.ERROR);
  3816.                             ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_ECCEZIONI_NON_VALIDA_POSIZIONE_SOAP_FAULT_DETAILS_PRESENTI.toString());
  3817.                             this.errorsTrovatiSullaListaEccezioni.add(ecc);
  3818.                         }
  3819.                     }
  3820.                     if ("Server".equals(codeS.getLocalName()) ){
  3821.                         // Con soap:Server, ci deve essere FAULT_STRING_PROCESSAMENTO_SPCOOP!
  3822.                         if ( !(SPCoopCostanti.FAULT_STRING_PROCESSAMENTO.equals(faultS)) ) {
  3823.                             Eccezione ecc = new Eccezione();
  3824.                             ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  3825.                             ecc.setCodiceEccezione(CodiceErroreCooperazione.FORMATO_CORPO_NON_CORRETTO);
  3826.                             ecc.setRilevanza(LivelloRilevanza.ERROR);
  3827.                             ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_ECCEZIONI_NON_VALIDA_POSIZIONE_SOAP_FAULT_STRING.toString());
  3828.                             this.errorsTrovatiSullaListaEccezioni.add(ecc);
  3829.                         }
  3830.                     }
  3831.                 }
  3832.             }
  3833.         }catch(Exception e){
  3834.             this.log.error("Errore durante la validazione del SoapFault",e);
  3835.             Eccezione ecc = new Eccezione();
  3836.             ecc.setContestoCodifica(ContestoCodificaEccezione.PROCESSAMENTO);
  3837.             ecc.setCodiceEccezione(CodiceErroreCooperazione.ERRORE_GENERICO_PROCESSAMENTO_MESSAGGIO);
  3838.             ecc.setRilevanza(LivelloRilevanza.ERROR);
  3839.             ecc.setDescrizione("Validazione SoapFault: errore di processamento");
  3840.             this.erroriProcessamento.add(ecc);
  3841.             return;
  3842.         }
  3843.     }



  3847.     public void validazioneManifestAttachmentsEGov(OpenSPCoop2Message msgParam,ProprietaManifestAttachments proprietaManifestAttachments){
  3848.         //log.info("VALIDAZIONE MANIFEST");
  3849.         SOAPBody soapBody = null;
  3850.         try{
  3851.             OpenSPCoop2SoapMessage msg = msgParam.castAsSoap();
  3852.             OpenSPCoop2MessageFactory messageFactory = msg.getFactory();
  3853.             
  3854.             java.util.List<String> contentID = new java.util.ArrayList<>();
  3855.             java.util.List<String> contentLocation = new java.util.ArrayList<>();
  3856.             java.util.Iterator<?> it = msg.getAttachments();
  3857.             
  3858.             while(it.hasNext()){
  3859.                 AttachmentPart ap = (AttachmentPart) it.next();
  3860.                 contentID.add(ap.getContentId());
  3861.                 contentLocation.add(ap.getContentLocation());
  3862.                 //log.info("Attachments con ID["+ap.getContentId()+"] e Location["+ap.getContentLocation()+"]");
  3863.             }



  3867.             boolean isRichiesta = false;
  3868.             boolean isRisposta = false;

  3870.             soapBody = msg.getSOAPBody();
  3871.             List<Node> soapBodyList = SoapUtils.getNotEmptyChildNodes(messageFactory, soapBody);
  3872.             if(soapBodyList.size()!=1){
  3873.                 // Il body deve possedere esattamente un elemento
  3874.                 Eccezione ecc = new Eccezione();
  3875.                 ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  3876.                 ecc.setCodiceEccezione(CodiceErroreCooperazione.ALLEGATI);
  3877.                 ecc.setRilevanza(LivelloRilevanza.ERROR);
  3878.                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_MANIFEST_POSIZIONE+" child size:"+soapBodyList.size());
  3879.                 this.erroriValidazione.add(ecc);
  3880.                 return;
  3881.             }

  3883.             //log.info("Validazione Descrizione...");
  3884.             Node descrizione = soapBodyList.get(0);
  3885.             String prefixManifest = descrizione.getPrefix();
  3886.             if(prefixManifest== null)
  3887.                 prefixManifest = "";
  3888.             if("".equals(prefixManifest)==false)
  3889.                 prefixManifest = prefixManifest + ":";
  3890.             //log.info("esamino["+descrizione.getNodeName()+"]");
  3891.             //if(!(descrizione.getNodeName().equals(prefixManifest+"Descrizione"))){
  3892.             if(!(SoapUtils.matchLocalName(messageFactory, descrizione, "Descrizione", prefixManifest, SPCoopCostanti.NAMESPACE_EGOV))){     
  3893.                 // Elemento Descrizione non esistente
  3894.                 Eccezione ecc = new Eccezione();
  3895.                 ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  3896.                 ecc.setCodiceEccezione(CodiceErroreCooperazione.ALLEGATI);
  3897.                 ecc.setRilevanza(LivelloRilevanza.ERROR);
  3898.                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_MANIFEST_POSIZIONE_DESCRIZIONE.toString());
  3899.                 this.erroriValidazione.add(ecc);
  3900.                 return;
  3901.             }
  3902.             if(SPCoopCostanti.NAMESPACE_EGOV.equals(descrizione.getNamespaceURI())==false){
  3903.                 // Elemento Descrizione non esistente
  3904.                 Eccezione ecc = new Eccezione();
  3905.                 ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  3906.                 ecc.setCodiceEccezione(CodiceErroreCooperazione.ALLEGATI);
  3907.                 ecc.setRilevanza(LivelloRilevanza.ERROR);
  3908.                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_MANIFEST_POSIZIONE_DESCRIZIONE_NAMESPACE.toString());
  3909.                 this.erroriValidazione.add(ecc);
  3910.                 return;
  3911.             }




  3916.             List<Node> descrizioneMessaggi = SoapUtils.getNotEmptyChildNodes(messageFactory, descrizione);
  3917.             if(descrizioneMessaggi.size()<=0){
  3918.                 //  Elemento DescrizioneMessaggio non esistente
  3919.                 Eccezione ecc = new Eccezione();
  3920.                 ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  3921.                 ecc.setCodiceEccezione(CodiceErroreCooperazione.ALLEGATI);
  3922.                 ecc.setRilevanza(LivelloRilevanza.ERROR);
  3923.                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_MANIFEST_POSIZIONE_DESCRIZIONE+" child size:"+descrizioneMessaggi.size());
  3924.                 this.erroriValidazione.add(ecc);
  3925.                 return;
  3926.             }
  3927.             for(int i=0; i<descrizioneMessaggi.size();i++){

  3929.                 //log.info("Validazione DescrizioneMessaggio...");
  3930.                 Node descrizioneMessaggio = descrizioneMessaggi.get(i);
  3931.                 //log.info("esamino["+descrizioneMessaggio.getNodeName()+"]");
  3932.                 //if(!(descrizioneMessaggio.getNodeName().equals(prefixManifest+SPCoopCostanti.LOCAL_NAME_MANIFEST_EGOV_DESCRIZIONE_MESSAGGIO))){
  3933.                 if(!(SoapUtils.matchLocalName(messageFactory, descrizioneMessaggio, SPCoopCostanti.LOCAL_NAME_MANIFEST_EGOV_DESCRIZIONE_MESSAGGIO, prefixManifest, SPCoopCostanti.NAMESPACE_EGOV))){
  3934.                     //  Elemento DescrizioneMessaggio non esistente
  3935.                     Eccezione ecc = new Eccezione();
  3936.                     ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  3937.                     ecc.setCodiceEccezione(CodiceErroreCooperazione.ALLEGATI);
  3938.                     ecc.setRilevanza(LivelloRilevanza.ERROR);
  3939.                     ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_MANIFEST_POSIZIONE_DESCRIZIONE+"/child["+descrizioneMessaggio.getNodeName()+"]");
  3940.                     this.erroriValidazione.add(ecc);
  3941.                     continue;
  3942.                 }

  3944.                 //log.info("Validazione Riferimento...");
  3945.                 List<Node> riferimentoList = SoapUtils.getNotEmptyChildNodes(messageFactory, descrizioneMessaggio);
  3946.                 if(riferimentoList.size()!=1){
  3947.                     //  Elemento Riferimento non esistente
  3948.                     Eccezione ecc = new Eccezione();
  3949.                     ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  3950.                     ecc.setCodiceEccezione(CodiceErroreCooperazione.ALLEGATI);
  3951.                     ecc.setRilevanza(LivelloRilevanza.ERROR);
  3952.                     ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_MANIFEST_POSIZIONE_DESCRIZIONE_DESCRIZIONE_MESSAGGIO +" child size:"+riferimentoList.size());
  3953.                     this.erroriValidazione.add(ecc);
  3954.                     continue;
  3955.                 }
  3956.                 Node riferimento = riferimentoList.get(0);
  3957.                 //log.info("esamino["+riferimento.getNodeName()+"]");
  3958.                 //if(!(riferimento.getNodeName().equals(prefixManifest+"Riferimento"))){
  3959.                 if(!(SoapUtils.matchLocalName(messageFactory, riferimento, "Riferimento", prefixManifest, SPCoopCostanti.NAMESPACE_EGOV))){
  3960.                     //  Elemento Riferimento non esistente
  3961.                     Eccezione ecc = new Eccezione();
  3962.                     ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  3963.                     ecc.setCodiceEccezione(CodiceErroreCooperazione.ALLEGATI_RIFERIMENTO_NON_PRESENTE);
  3964.                     ecc.setRilevanza(LivelloRilevanza.ERROR);
  3965.                     ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_MANIFEST_POSIZIONE_DESCRIZIONE_DESCRIZIONE_MESSAGGIO+"/child["+riferimento.getNodeName()+"]");
  3966.                     this.erroriValidazione.add(ecc);
  3967.                     continue;
  3968.                 }

  3970.                 // href
  3971.                 String href = null;
  3972.                 boolean hrefError = false;
  3973.                 try{
  3974.                     Node hrefFind = null;
  3975.                     if(this.readQualifiedAttribute){
  3976.                         hrefFind = SoapUtils.getQualifiedAttributeNode(messageFactory, riferimento, "href", SPCoopCostanti.NAMESPACE_EGOV);
  3977.                     }else{
  3978.                         hrefFind = SoapUtils.getAttributeNode(messageFactory, riferimento, "href");
  3979.                     }
  3980.                     href = hrefFind.getNodeValue();
  3981.                 } catch(Exception e) {
  3982.                     hrefError = true;
  3983.                 }
  3984.                 if(href == null)
  3985.                     hrefError = true;
  3986.                 if(hrefError){
  3987.                     //  Elemento Riferimento non esistente
  3988.                     Eccezione ecc = new Eccezione();
  3989.                     ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  3990.                     ecc.setCodiceEccezione(CodiceErroreCooperazione.ALLEGATI_RIFERIMENTO_NON_VALIDO);
  3991.                     ecc.setRilevanza(LivelloRilevanza.ERROR);
  3992.                     ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_MANIFEST_POSIZIONE_DESCRIZIONE_DESCRIZIONE_MESSAGGIO_RIFERIMENTO_HREF.toString());
  3993.                     this.erroriValidazione.add(ecc);
  3994.                     continue;
  3995.                 }
  3996.                 // VALIDAZIONE HREF
  3997.                 
  3998.                 
  3999.                 
  4000.                 boolean findHRef = false;
  4001.                 for(int k=0; k<contentID.size(); k++){
  4002.                     if(href.equals(contentID.get(k)) || 
  4003.                             href.equals("cid:"+contentID.get(k)) ||
  4004.                             href.equals(contentLocation.get(k)) ){
  4005.                         contentID.remove(k);
  4006.                         contentLocation.remove(k);
  4007.                         findHRef = true;
  4008.                         break;
  4009.                     }
  4010.                     else{
  4011.                         // verifico se per caso l'href fornito non contiene i '<' e '>'.
  4012.                         // per retrocompatibilità provo ad aggiungergli io
  4013.                         String hrefNew = new String(href);
  4014.                         String cidPref = "";
  4015.                         if(hrefNew.startsWith("cid:")){
  4016.                             hrefNew = hrefNew.substring("cid:".length());
  4017.                             cidPref = "cid:";
  4018.                         }
  4019.                         if(hrefNew.startsWith("<")==false){
  4020.                             hrefNew = "<"+hrefNew;
  4021.                         }
  4022.                         if(hrefNew.endsWith(">")==false){
  4023.                             hrefNew = hrefNew + ">";
  4024.                         }
  4025.                         hrefNew = cidPref + hrefNew;
  4026.                         if(hrefNew.equals(href)==false){
  4027.                             if(hrefNew.equals(contentID.get(k)) || 
  4028.                                     hrefNew.equals("cid:"+contentID.get(k)) ){
  4029.                                 contentID.remove(k);
  4030.                                 contentLocation.remove(k);
  4031.                                 findHRef = true;
  4032.                                 break;
  4033.                             }
  4034.                         }
  4035.                     }
  4036.                 }
  4037.                 if(findHRef == false){
  4038.                     //  RiferimentoAttachment non esistente
  4039.                     Eccezione ecc = new Eccezione();
  4040.                     ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  4041.                     ecc.setCodiceEccezione(CodiceErroreCooperazione.ALLEGATO_NON_PRESENTE);
  4042.                     ecc.setRilevanza(LivelloRilevanza.ERROR);
  4043.                     ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_MANIFEST_POSIZIONE_DESCRIZIONE_DESCRIZIONE_MESSAGGIO_RIFERIMENTO_HREF+"["+href+"]");
  4044.                     this.erroriValidazione.add(ecc);
  4045.                 }


  4048.                 // role
  4049.                 String role = null;
  4050.                 boolean roleError = false;
  4051.                 try{
  4052.                     Node roleFind = null;
  4053.                     if(this.readQualifiedAttribute){
  4054.                         roleFind = SoapUtils.getQualifiedAttributeNode(messageFactory, riferimento, "role", SPCoopCostanti.NAMESPACE_EGOV);
  4055.                     }else{
  4056.                         roleFind = SoapUtils.getAttributeNode(messageFactory, riferimento, "role");
  4057.                     }
  4058.                     role = roleFind.getNodeValue();
  4059.                 } catch(Exception e) {
  4060.                     roleError = true;
  4061.                 }
  4062.                 if(role == null)
  4063.                     roleError = true;
  4064.                 if(roleError){
  4065.                     //  Elemento Riferimento non esistente
  4066.                     Eccezione ecc = new Eccezione();
  4067.                     ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  4068.                     ecc.setCodiceEccezione(CodiceErroreCooperazione.ALLEGATI);
  4069.                     ecc.setRilevanza(LivelloRilevanza.ERROR);
  4070.                     ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_MANIFEST_POSIZIONE_DESCRIZIONE_DESCRIZIONE_MESSAGGIO_RIFERIMENTO_ROLE.toString());
  4071.                     this.erroriValidazione.add(ecc);
  4072.                     continue;
  4073.                 }

  4075.                 // CHECK Semantica Ruolo
  4076.                 if(this.spcoopProperties.getRoleRichiestaManifest().equalsIgnoreCase(role) ||
  4077.                         this.spcoopProperties.getRoleRispostaManifest().equalsIgnoreCase(role)  ){
  4078.                     if(isRichiesta || isRisposta){
  4079.                         //  Doppio elemento 'Richiesta/Risposta'
  4080.                         Eccezione ecc = new Eccezione();
  4081.                         ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  4082.                         // uso il riferiemnto non valido per farlo tradurre con codice 118 e quindi farlo gestire bene ad InoltroBuste, per non far gestire il manifest in fase di sbustamento
  4083.                         ecc.setCodiceEccezione(CodiceErroreCooperazione.ALLEGATI_RIFERIMENTO_NON_VALIDO);
  4084.                         ecc.setRilevanza(LivelloRilevanza.ERROR);
  4085.                         // (Manifest degli attachments) Esistono più di una descrizione di messaggio
  4086.                         // con 'role' discriminante ('"+Costanti.ATTACHMENTS_MANIFEST_RICHIESTA+"'/'"+Costanti.ATTACHMENTS_MANIFEST_RISPOSTA+"').
  4087.                         String posizioneErrore = SPCoopCostantiPosizioneEccezione.ECCEZIONE_MANIFEST_POSIZIONE_DESCRIZIONE_DESCRIZIONE_MESSAGGIO_RIFERIMENTO_ROLE_PRINCIPALE_DUPLICATO.toString();
  4088.                         posizioneErrore = posizioneErrore.replace(SPCoopCostanti.MANIFEST_KEY_ROLE_RICHIESTA, this.spcoopProperties.getRoleRichiestaManifest());
  4089.                         posizioneErrore = posizioneErrore.replace(SPCoopCostanti.MANIFEST_KEY_ROLE_RISPOSTA, this.spcoopProperties.getRoleRispostaManifest());
  4090.                         ecc.setDescrizione(posizioneErrore);
  4091.                         this.erroriValidazione.add(ecc);
  4092.                         continue;
  4093.                     }
  4094.                     if(this.spcoopProperties.getRoleRichiestaManifest().equalsIgnoreCase(role))
  4095.                         isRichiesta = true;
  4096.                     else
  4097.                         isRisposta = true;
  4098.                 }


  4101.                 // id
  4102.                 String id = null;
  4103.                 boolean idError = false;
  4104.                 try{
  4105.                     // Deve essere sempre preso come qualificato.
  4106.                     Node idFind = SoapUtils.getQualifiedAttributeNode(messageFactory, riferimento, "id", SPCoopCostanti.NAMESPACE_EGOV);
  4107.                     id = idFind.getNodeValue();
  4108.                 } catch(Exception e) {
  4109.                     idError = true;
  4110.                 }
  4111.                 if(id == null)
  4112.                     idError = true;
  4113.                 if(idError){
  4114.                     //  Elemento Riferimento non esistente
  4115.                     Eccezione ecc = new Eccezione();
  4116.                     ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  4117.                     ecc.setCodiceEccezione(CodiceErroreCooperazione.ALLEGATI);
  4118.                     ecc.setRilevanza(LivelloRilevanza.ERROR);
  4119.                     ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_MANIFEST_POSIZIONE_DESCRIZIONE_DESCRIZIONE_MESSAGGIO_RIFERIMENTO_ID.toString());
  4120.                     this.erroriValidazione.add(ecc);
  4121.                     continue;
  4122.                 }


  4125.                 // check elementi Schema e Titolo
  4126.                 List<Node> elementiRiferimento = SoapUtils.getNotEmptyChildNodes(messageFactory, riferimento);
  4127.                 if(elementiRiferimento.size()!=2){
  4128.                     //  Elemento Schema non esistente
  4129.                     Eccezione ecc = new Eccezione();
  4130.                     ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  4131.                     ecc.setCodiceEccezione(CodiceErroreCooperazione.ALLEGATI);
  4132.                     ecc.setRilevanza(LivelloRilevanza.ERROR);
  4133.                     ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_MANIFEST_POSIZIONE_DESCRIZIONE_DESCRIZIONE_MESSAGGIO_RIFERIMENTO+" child size:"+elementiRiferimento.size());
  4134.                     this.erroriValidazione.add(ecc);
  4135.                     continue;
  4136.                 }

  4138.                 Node child = elementiRiferimento.get(0);
  4139.                 Node schema = null;
  4140.                 Node titolo = null;
  4141.                 //if(child.getNodeName().equals(prefixManifest+"Schema")){
  4142.                 if(SoapUtils.matchLocalName(messageFactory, child, "Schema", prefixManifest, SPCoopCostanti.NAMESPACE_EGOV)){
  4143.                     schema = child;
  4144.                     titolo = elementiRiferimento.get(1);                
  4145.                 //}else if(child.getNodeName().equals(prefixManifest+"Titolo")){
  4146.                 }else if(SoapUtils.matchLocalName(messageFactory, child, "Titolo", prefixManifest, SPCoopCostanti.NAMESPACE_EGOV)){ 
  4147.                     titolo = child;
  4148.                     schema = elementiRiferimento.get(1);
  4149.                 }else{
  4150.                     Eccezione ecc = new Eccezione();
  4151.                     ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  4152.                     ecc.setCodiceEccezione(CodiceErroreCooperazione.ALLEGATI);
  4153.                     ecc.setRilevanza(LivelloRilevanza.ERROR);
  4154.                     ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_MANIFEST_POSIZIONE_DESCRIZIONE_DESCRIZIONE_MESSAGGIO_RIFERIMENTO+"/child["+child.getNodeName()+"]");
  4155.                     this.erroriValidazione.add(ecc);
  4156.                     continue;
  4157.                 }


  4160.                 //log.info("Validazione Schema...");            
  4161.                 //log.info("esamino["+schema.getNodeName()+"]");
  4162.                 //if(!(schema.getNodeName().equals(prefixManifest+"Schema"))){
  4163.                 if(!(SoapUtils.matchLocalName(messageFactory, schema, "Schema", prefixManifest, SPCoopCostanti.NAMESPACE_EGOV))){
  4164.                     //  Elemento Riferimento non esistente
  4165.                     Eccezione ecc = new Eccezione();
  4166.                     ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  4167.                     ecc.setCodiceEccezione(CodiceErroreCooperazione.ALLEGATI);
  4168.                     ecc.setRilevanza(LivelloRilevanza.ERROR);
  4169.                     ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_MANIFEST_POSIZIONE_DESCRIZIONE_DESCRIZIONE_MESSAGGIO_RIFERIMENTO_SCHEMA.toString());
  4170.                     this.erroriValidazione.add(ecc);
  4171.                     continue;
  4172.                 }

  4174.                 // posizione
  4175.                 String posizione = null;
  4176.                 boolean posizioneError = false;
  4177.                 try{
  4178.                     Node posizioneFind = null;
  4179.                     if(this.readQualifiedAttribute){
  4180.                         posizioneFind = SoapUtils.getQualifiedAttributeNode(messageFactory, schema, "posizione", SPCoopCostanti.NAMESPACE_EGOV);
  4181.                     }else{
  4182.                         posizioneFind = SoapUtils.getAttributeNode(messageFactory, schema, "posizione");
  4183.                     }
  4184.                     posizione = posizioneFind.getNodeValue();
  4185.                 } catch(Exception e) {
  4186.                     posizioneError = true;
  4187.                 }
  4188.                 if(posizione == null)
  4189.                     posizioneError = true;
  4190.                 if(posizioneError){
  4191.                     //  Elemento Riferimento non esistente
  4192.                     Eccezione ecc = new Eccezione();
  4193.                     ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  4194.                     ecc.setCodiceEccezione(CodiceErroreCooperazione.ALLEGATI);
  4195.                     ecc.setRilevanza(LivelloRilevanza.ERROR);
  4196.                     ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_MANIFEST_POSIZIONE_DESCRIZIONE_DESCRIZIONE_MESSAGGIO_RIFERIMENTO_SCHEMA_POSIZIONE.toString());
  4197.                     this.erroriValidazione.add(ecc);
  4198.                     continue;
  4199.                 }



  4203.                 //log.info("Validazione Titolo...");
  4204.                 //log.info("esamino["+titolo.getNodeName()+"]");
  4205.                 //if(!(titolo.getNodeName().equals(prefixManifest+"Titolo"))){
  4206.                 if(!(SoapUtils.matchLocalName(messageFactory, titolo, "Titolo", prefixManifest, SPCoopCostanti.NAMESPACE_EGOV))){
  4207.                     //  Elemento Riferimento non esistente
  4208.                     Eccezione ecc = new Eccezione();
  4209.                     ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  4210.                     ecc.setCodiceEccezione(CodiceErroreCooperazione.ALLEGATI);
  4211.                     ecc.setRilevanza(LivelloRilevanza.ERROR);
  4212.                     ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_MANIFEST_POSIZIONE_DESCRIZIONE_DESCRIZIONE_MESSAGGIO_RIFERIMENTO_TITOLO.toString());
  4213.                     this.erroriValidazione.add(ecc);
  4214.                     continue;
  4215.                 }

  4217.                 // Lingua
  4218.                 String Lingua = null;
  4219.                 try{
  4220.                     Node LinguaFind = null;
  4221.                     if(this.readQualifiedAttribute){
  4222.                         LinguaFind = SoapUtils.getQualifiedAttributeNode(messageFactory, titolo, "Lingua", SPCoopCostanti.NAMESPACE_EGOV);
  4223.                     }else{
  4224.                         LinguaFind = SoapUtils.getAttributeNode(messageFactory, titolo, "Lingua");
  4225.                     }
  4226.                     Lingua = LinguaFind.getNodeValue();
  4227.                 } catch(Exception e) {
  4228.                     // ignore
  4229.                 }
  4230.                 if(Lingua == null)
  4231.                     Lingua = "it"; // default is it

  4233.                 String valoreTitolo = null;
  4234.                 try{
  4235.                     valoreTitolo = SoapUtils.getNotEmptyChildNodes(messageFactory, titolo).get(0).getNodeValue();
  4236.                     if(valoreTitolo == null)
  4237.                         throw new Exception("valore non presente");
  4238.                 } catch(Exception e) {
  4239.                     //  Elemento Titolo con scorretto valore
  4240.                     Eccezione ecc = new Eccezione();
  4241.                     ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  4242.                     ecc.setCodiceEccezione(CodiceErroreCooperazione.ALLEGATI);
  4243.                     ecc.setRilevanza(LivelloRilevanza.ERROR);
  4244.                     ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_MANIFEST_POSIZIONE_DESCRIZIONE_DESCRIZIONE_MESSAGGIO_RIFERIMENTO_TITOLO.toString());
  4245.                     this.erroriValidazione.add(ecc);
  4246.                     continue;
  4247.                 }
  4248.             }

  4250.             // Validazione role Richiesta/Risposta
  4251.             if( isRichiesta==false && isRisposta ==false){
  4252.                 Eccezione ecc = new Eccezione();
  4253.                 ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  4254.                 // uso il riferiemnto non valido per farlo tradurre con codice 118 e quindi farlo gestire bene ad InoltroBuste, per non far gestire il manifest in fase di sbustamento
  4255.                 ecc.setCodiceEccezione(CodiceErroreCooperazione.ALLEGATI_RIFERIMENTO_NON_VALIDO);
  4256.                 ecc.setRilevanza(LivelloRilevanza.ERROR);
  4257.                 String posizioneErrore = SPCoopCostantiPosizioneEccezione.ECCEZIONE_MANIFEST_POSIZIONE_DESCRIZIONE_DESCRIZIONE_MESSAGGIO_RIFERIMENTO_ROLE_PRINCIPALE_ASSENTE.toString();
  4258.                 posizioneErrore = posizioneErrore.replace(SPCoopCostanti.MANIFEST_KEY_ROLE_RICHIESTA, this.spcoopProperties.getRoleRichiestaManifest());
  4259.                 posizioneErrore = posizioneErrore.replace(SPCoopCostanti.MANIFEST_KEY_ROLE_RISPOSTA, this.spcoopProperties.getRoleRispostaManifest());
  4260.                 ecc.setDescrizione(posizioneErrore);
  4261.                 this.erroriValidazione.add(ecc);
  4262.                 return;
  4263.             }


  4266.             // Validazione href
  4267.             while(contentID.size()>0){
  4268.                 //  RiferimentoAttachment non definito in manifest
  4269.                 Eccezione ecc = new Eccezione();
  4270.                 ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  4271.                 ecc.setCodiceEccezione(CodiceErroreCooperazione.ALLEGATO_NON_DEFINITO_MANIFEST);
  4272.                 ecc.setRilevanza(LivelloRilevanza.ERROR);
  4273.                 String href = contentID.remove(0);
  4274.                 if(href==null)
  4275.                     href = contentLocation.remove(0);
  4276.                 else
  4277.                     contentLocation.remove(0);
  4278.                 // (Manifest degli attachments) Allegato con id/location ["+href+"] non riferito attraverso opportuno elemento nel Manifest degli attachments.
  4279.                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_MANIFEST_POSIZIONE_DESCRIZIONE_DESCRIZIONE_MESSAGGIO_RIFERIMENTO_HREF+"["+href+"] non presente");
  4280.                 this.erroriValidazione.add(ecc);
  4281.             }
  4282.             return;

  4284.         }catch(Exception e){
  4285.             this.log.error("Errore durante la validazione del Manifest degli attachments",e);
  4286.             Eccezione ecc = new Eccezione();
  4287.             ecc.setContestoCodifica(ContestoCodificaEccezione.PROCESSAMENTO);
  4288.             ecc.setCodiceEccezione(CodiceErroreCooperazione.ERRORE_GENERICO_PROCESSAMENTO_MESSAGGIO);
  4289.             ecc.setRilevanza(LivelloRilevanza.ERROR);
  4290.             ecc.setDescrizione("Manifest degli attachments: errore di processamento");
  4291.             this.erroriProcessamento.add(ecc);
  4292.             return;
  4293.         }
  4294.         finally{
  4295.             // *** GB ***
  4296.             soapBody = null;
  4297.             // *** GB ***
  4298.         }

  4300.     }




  4305.     /**
  4306.      * Metodo che si occupa di validare la data <var>aDate</var>
  4307.      * secondo la specifica eGov.
  4308.      * La Data deve essere formato da :
  4309.      * yyyy-MM-ddThh:mm:ss[.SSS]    (es. il 23/03/2005 alle 13:56:01 viene registrato come 2005-03-23T13:56:01)
  4310.      * In caso la validazione abbia successo, viene ritornato un oggetto Date inizializzato alla data <var>aDate</var>.
  4311.      *
  4312.      * @param aDate data eGov da validare
  4313.      * @return un oggetto Date inizializzato  alla <var>aDate</var>, se essa e' conforme alla specifica eGov, null altrimenti.
  4314.      * 
  4315.      */
  4316.     private Date validazioneData(String aDate){

  4318.         try{

  4320.             String [] split = aDate.split("T");
  4321.             if(split == null)
  4322.                 return null;
  4323.             if(split.length != 2)
  4324.                 return null;

  4326.             // Check data yyyy-MM-dd
  4327.             String [] date = split[0].split("-");
  4328.             if(date == null)
  4329.                 return null;
  4330.             if(date.length != 3)
  4331.                 return null;
  4332.             if(date[0].length() != 4)
  4333.                 return null;
  4334.             try{
  4335.                 Integer test = Integer.valueOf(date[0]);
  4336.                 if(test.intValue()>2100)
  4337.                     return null;
  4338.             } catch(Exception e){
  4339.                 return null;
  4340.             } 
  4341.             if(date[1].length() != 2)
  4342.                 return null;
  4343.             if(date[2].length() != 2)
  4344.                 return null;
  4345.             try{
  4346.                 Integer mese = Integer.valueOf(date[1]);
  4347.                 if(mese.intValue()>12 || mese.intValue() < 0)
  4348.                     return null;
  4349.                 Integer giorno = Integer.valueOf(date[2]);
  4350.                 if(giorno.intValue() < 0)
  4351.                     return null;
  4352.                 if(giorno.intValue()>29 && mese.intValue() == 2)
  4353.                     return null;
  4354.                 else if(giorno.intValue()>30 && 
  4355.                         (  (mese.intValue() == 4) ||
  4356.                                 (mese.intValue() == 6) ||
  4357.                                 (mese.intValue() == 9) ||
  4358.                                 (mese.intValue() == 11) ) )
  4359.                     return null;
  4360.                 else if(giorno.intValue()>31)
  4361.                     return null;
  4362.             } catch(Exception e){
  4363.                 return null;
  4364.             } 

  4366.             // Check ora hh:mm:ss
  4367.             String [] ora = split[1].split(":");
  4368.             if(ora == null)
  4369.                 return null;
  4370.             if(ora.length < 3)
  4371.                 return null;

  4373.             // Check ora
  4374.             if(ora[0].length() != 2)
  4375.                 return null;
  4376.             try{
  4377.                 Integer test = Integer.valueOf(ora[0]);
  4378.                 if(test.intValue() > 23 || test.intValue() < 0)
  4379.                     return null;
  4380.             } catch(Exception e){
  4381.                 return null;
  4382.             } 

  4384.             if(ora[1].length() != 2)
  4385.                 return null;
  4386.             try{
  4387.                 Integer test = Integer.valueOf(ora[1]);
  4388.                 if(test.intValue() > 59 || test.intValue() < 0)
  4389.                     return null;
  4390.             } catch(Exception e){
  4391.                 return null;
  4392.             } 


  4395.             // Secondi...
  4396.             String secondi = null;
  4397.             if(ora[2].length() < 2)
  4398.                 return null;
  4399.             try{
  4400.                 secondi = "" + ora[2].charAt(0) + ora[2].charAt(1);
  4401.                 Integer test = Integer.valueOf(secondi);
  4402.                 if(test.intValue() > 59 || test.intValue() < 0)
  4403.                     return null;
  4404.             } catch(Exception e){
  4405.                 return null;
  4406.             } 

  4408.             GregorianCalendar calendar = null;
  4409.             try{
  4410.                 calendar = 
  4411.                     new GregorianCalendar( (Integer.valueOf(date[0])).intValue(),
  4412.                             ((Integer.valueOf(date[1])).intValue()-1), // il mese is 0-Based
  4413.                             (Integer.valueOf(date[2])).intValue(),
  4414.                             (Integer.valueOf(ora[0])).intValue(),
  4415.                             (Integer.valueOf(ora[1])).intValue(),
  4416.                             (Integer.valueOf(secondi)).intValue());
  4417.             } catch(Exception e){
  4418.                 return null;
  4419.             } 

  4421.             long value = (calendar.getTime()).getTime(); //+ (1000 * 60 *60);
  4422.             return new Date(value);

  4424.         }catch(Exception error){
  4425.             return null;
  4426.         }
  4427.     }



  4431.     /**
  4432.      * Metodo che si occupa di verificare che la data <var>scadenza</var> descritta con un formato
  4433.      * conforme alla specifica eGov, non sia scaduta.
  4434.      * La Data deve essere formato da :
  4435.      * yyyy-MM-ddThh:mm:ss    (es. il 23/03/2005 alle 13:56:01 viene registrato come 2005-03-23T13:56:01)
  4436.      *
  4437.      * @param scadenza data eGov da controllare se e' scaduta o meno.
  4438.      * @return un boolean true se la data non e' scaduta. Altrimenti false.
  4439.      * 
  4440.      */
  4441.     private boolean dataScaduta(String scadenza){
  4442.         Date now=DateManager.getDate();
  4443.         SimpleDateFormat dateformat = DateUtils.getDefaultDateTimeFormatter("yyyy MM dd HH mm ss");
  4444.         String nowFormat = dateformat.format(now);
  4445.         String scadenzaFormat = ((scadenza.replace('-',' ')).replace(':',' ')).replace('T',' ');
  4446.         String [] splitNow = nowFormat.split(" ");
  4447.         String [] splitScadenza = scadenzaFormat.split(" ");


  4450.         if (validazioneData(scadenza)  == null)
  4451.             return false;

  4453.         try{
  4454.             Integer testNowAnno = Integer.valueOf(splitNow[0]);
  4455.             Integer testScadenzaAnno = Integer.valueOf(splitScadenza[0]);
  4456.             Integer testNowMese = Integer.valueOf(splitNow[1]);
  4457.             Integer testScadenzaMese = Integer.valueOf(splitScadenza[1]);
  4458.             Integer testNowGiorno = Integer.valueOf(splitNow[2]);
  4459.             Integer testScadenzaGiorno = Integer.valueOf(splitScadenza[2]);
  4460.             Integer testNowOra = Integer.valueOf(splitNow[3]);
  4461.             Integer testScadenzaOra = Integer.valueOf(splitScadenza[3]);
  4462.             Integer testNowMinuti = Integer.valueOf(splitNow[4]);
  4463.             Integer testScadenzaMinuti = Integer.valueOf(splitScadenza[4]);
  4464.             Integer testNowSecondi = Integer.valueOf(splitNow[5]);
  4465.             Integer testScadenzaSecondi = Integer.valueOf(splitScadenza[5].charAt(0) + splitScadenza[5].charAt(1));
  4466.             if(testNowAnno.intValue() > testScadenzaAnno.intValue())
  4467.                 return true;
  4468.             else if ( (testNowAnno.intValue() == testScadenzaAnno.intValue()) &&
  4469.                     (testNowMese.intValue() > testScadenzaMese.intValue()) )
  4470.                 return true;
  4471.             else if ( (testNowAnno.intValue() == testScadenzaAnno.intValue()) &&
  4472.                     (testNowMese.intValue() == testScadenzaMese.intValue()) &&
  4473.                     (testNowGiorno.intValue() > testScadenzaGiorno.intValue()) )
  4474.                 return true;
  4475.             else if ( (testNowAnno.intValue() == testScadenzaAnno.intValue()) &&
  4476.                     (testNowMese.intValue() == testScadenzaMese.intValue()) &&
  4477.                     (testNowGiorno.intValue() == testScadenzaGiorno.intValue()) &&
  4478.                     (testNowOra.intValue() > testScadenzaOra.intValue()) )
  4479.                 return true;
  4480.             else if ( (testNowAnno.intValue() == testScadenzaAnno.intValue()) &&
  4481.                     (testNowMese.intValue() == testScadenzaMese.intValue()) &&
  4482.                     (testNowGiorno.intValue() == testScadenzaGiorno.intValue()) &&
  4483.                     (testNowOra.intValue() == testScadenzaOra.intValue()) &&
  4484.                     (testNowMinuti.intValue() > testScadenzaMinuti.intValue()) )
  4485.                 return true;
  4486.             else if ( (testNowAnno.intValue() == testScadenzaAnno.intValue()) &&
  4487.                     (testNowMese.intValue() == testScadenzaMese.intValue()) &&
  4488.                     (testNowGiorno.intValue() == testScadenzaGiorno.intValue()) &&
  4489.                     (testNowOra.intValue() == testScadenzaOra.intValue()) &&
  4490.                     (testNowMinuti.intValue() == testScadenzaMinuti.intValue()) &&
  4491.                     (testNowSecondi.intValue() > testScadenzaSecondi.intValue()) )
  4492.                 return true;

  4494.         } catch(Exception e){
  4495.             return true;
  4496.         } 

  4498.         return false;
  4499.     }
  4500.     
  4501.         
  4502.     private void validazioneDatePresentiRispettoDateFuture() throws ProtocolException{
  4503.         
  4504.         int intervalloTolleranza = this.spcoopProperties.getIntervalloMinutiTolleranzaDateFuture();
  4505.         
  4506.         Date sistema = DateManager.getDate();
  4507.         Date dataFuturaMassimaAccettata = new Date(sistema.getTime()+(intervalloTolleranza*60*1000));
  4508.         
  4509.         
  4510.         // Ora Registrazione, altrimenti segnalero' il problema
  4511.         if(this.busta.getOraRegistrazione()!=null){
  4512.             if( this.busta.getOraRegistrazione().after(dataFuturaMassimaAccettata)){
  4513.                 this.log.error("Data portata nell'ora di registrazione ["+SPCoopUtils.getDate_eGovFormat(this.busta.getOraRegistrazione())+"] futura rispetto all'ora attuale di sistema ("+
  4514.                         SPCoopUtils.getDate_eGovFormat(sistema)+") e l'intervallo di tolleranza impostato a "+intervalloTolleranza+" minuti");
  4515.                 Eccezione ecc = new Eccezione();
  4516.                 ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  4517.                 ecc.setCodiceEccezione(CodiceErroreCooperazione.ORA_REGISTRAZIONE_NON_VALIDA);
  4518.                 ecc.setRilevanza(LivelloRilevanza.ERROR);
  4519.                 ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_ORA_REGISTRAZIONE_NON_VALIDA_POSIZIONE.toString());
  4520.                 this.erroriValidazione.add(ecc);
  4521.             }
  4522.         }
  4523.         
  4524.         // Check su id egov
  4525.         // Se correttamente formato, altrimenti segnalero' il problema
  4526.         if(this.busta.getID()!=null){
  4527.             String [] split = this.busta.getID().split("_");
  4528.             if(split != null && split.length == 5){
  4529.                 Date dataIntoIDEgov = null;
  4530.                 try{
  4531.                     SimpleDateFormat dateformat = DateUtils.getSimpleDateFormatMinute();
  4532.                     dataIntoIDEgov = dateformat.parse(split[3]+"_"+split[4]);
  4533.                 }catch(Exception e){
  4534.                     // ignore
  4535.                 }
  4536.                 if(dataIntoIDEgov!=null){
  4537.                     //System.out.println("DATA IDEGOV BUSTA ["+dataIntoIDEgov.toString()
  4538.                     //      +"]   MINIMA ["+oraRegistrazioneMinimaAccettata.toString()+"]");
  4539.                     if( dataIntoIDEgov.after(dataFuturaMassimaAccettata)){
  4540.                         this.log.error("Data portata nell'identificativo egov ["+this.busta.getID()+"]["+SPCoopUtils.getDate_eGovFormat(dataIntoIDEgov)+"] futura rispetto all'ora attuale di sistema ("+
  4541.                                 SPCoopUtils.getDate_eGovFormat(sistema)+") e l'intervallo di tolleranza impostato a "+intervalloTolleranza+" minuti");
  4542.                         Eccezione ecc = new Eccezione();
  4543.                         ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  4544.                         ecc.setCodiceEccezione(CodiceErroreCooperazione.IDENTIFICATIVO_MESSAGGIO_NON_VALIDO);
  4545.                         ecc.setRilevanza(LivelloRilevanza.ERROR);
  4546.                         ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_ID_MESSAGGIO_NON_VALIDO_POSIZIONE.toString());
  4547.                         this.erroriValidazione.add(ecc);
  4548.                     }
  4549.                 }
  4550.             }
  4551.         }
  4552.         
  4553.         // Ora Registrazione nei riscontri, altrimenti segnalero' il problema
  4554.         for(int i=0; i<this.busta.sizeListaRiscontri(); i++){
  4555.             Riscontro riscontro = this.busta.getRiscontro(i);
  4556.             if(riscontro.getOraRegistrazione()!=null){
  4557.                 if( riscontro.getOraRegistrazione().after(dataFuturaMassimaAccettata)){
  4558.                     this.log.error("Data portata nell'ora di registrazione del riscontro con id ["+riscontro.getID()+"] ["+SPCoopUtils.getDate_eGovFormat(riscontro.getOraRegistrazione())
  4559.                             +"] futura rispetto all'ora attuale di sistema ("+
  4560.                             SPCoopUtils.getDate_eGovFormat(sistema)+") e l'intervallo di tolleranza impostato a "+intervalloTolleranza+" minuti");
  4561.                     Eccezione ecc = new Eccezione();
  4562.                     ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  4563.                     ecc.setCodiceEccezione(CodiceErroreCooperazione.RISCONTRO_ORA_REGISTRAZIONE_NON_VALIDA);
  4564.                     ecc.setRilevanza(LivelloRilevanza.ERROR);
  4565.                     ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_RISCONTRI_NON_VALIDA_POSIZIONE_RISCONTRO_ORA_REGISTRAZIONE.toString());
  4566.                     this.erroriValidazione.add(ecc);
  4567.                 }
  4568.             }
  4569.         }
  4570.         
  4571.         // Ora Registrazione nelle trasmissioni, altrimenti segnalero' il problema
  4572.         for(int i=0; i<this.busta.sizeListaTrasmissioni(); i++){
  4573.             Trasmissione trasmissione = this.busta.getTrasmissione(i);
  4574.             if(trasmissione.getOraRegistrazione()!=null){
  4575.                 if( trasmissione.getOraRegistrazione().after(dataFuturaMassimaAccettata)){
  4576.                     this.log.error("Data portata nell'ora di registrazione di una trasmissione ["+SPCoopUtils.getDate_eGovFormat(trasmissione.getOraRegistrazione())
  4577.                             +"] futura rispetto all'ora attuale di sistema ("+
  4578.                             SPCoopUtils.getDate_eGovFormat(sistema)+") e l'intervallo di tolleranza impostato a "+intervalloTolleranza+" minuti");
  4579.                     Eccezione ecc = new Eccezione();
  4580.                     ecc.setContestoCodifica(ContestoCodificaEccezione.INTESTAZIONE);
  4581.                     ecc.setCodiceEccezione(CodiceErroreCooperazione.TRASMISSIONE_ORA_REGISTRAZIONE_NON_VALIDA);
  4582.                     ecc.setRilevanza(LivelloRilevanza.ERROR);
  4583.                     ecc.setDescrizione(SPCoopCostantiPosizioneEccezione.ECCEZIONE_LISTA_TRASMISSIONI_NON_VALIDA_POSIZIONE_TRASMISSIONE_ORA_REGISTRAZIONE.toString());
  4584.                     this.erroriValidazione.add(ecc);
  4585.                 }
  4586.             }
  4587.         }
  4588.     }


  4591.     @Override
  4592.     public ValidazioneSintatticaResult<SOAPHeaderElement> validaRichiesta(OpenSPCoop2Message msg,  Busta datiBustaLettiURLMappingProperties, ProprietaValidazioneErrori proprietaValidazioneErrori) throws ProtocolException{
  4593.         try{
  4594.             this.msg = msg.castAsSoap();
  4595.         }catch(Exception e){
  4596.             throw new ProtocolException(e.getMessage(),e);
  4597.         }
  4598.         boolean isValido = this.valida(false);
  4599.         ErroreCooperazione errore = null;
  4600.         if(this.msgErrore!=null && this.codiceErrore!=null){
  4601.             errore = new ErroreCooperazione(this.msgErrore, this.codiceErrore);
  4602.         }
  4603.         ValidazioneSintatticaResult<SOAPHeaderElement> result = new ValidazioneSintatticaResult<SOAPHeaderElement>(this.erroriValidazione, this.erroriProcessamento, 
  4604.                 this.errorsTrovatiSullaListaEccezioni, this.busta, errore, this.bustaErroreHeaderIntestazione, this.headerEGov, isValido);
  4605.         return result;
  4606.     }
  4607.     
  4608.     @Override
  4609.     public ValidazioneSintatticaResult<SOAPHeaderElement> validaRisposta(OpenSPCoop2Message msg, Busta bustaRichiesta, ProprietaValidazioneErrori proprietaValidazioneErrori) throws ProtocolException{
  4610.         try{
  4611.             this.msg = msg.castAsSoap();
  4612.         }catch(Exception e){
  4613.             throw new ProtocolException(e.getMessage(),e);
  4614.         }
  4615.         boolean isValido = this.valida(false);
  4616.         ErroreCooperazione errore = null;
  4617.         if(this.msgErrore!=null && this.codiceErrore!=null){
  4618.             errore = new ErroreCooperazione(this.msgErrore, this.codiceErrore);
  4619.         }
  4620.         ValidazioneSintatticaResult<SOAPHeaderElement> result = new ValidazioneSintatticaResult<SOAPHeaderElement>(this.erroriValidazione, this.erroriProcessamento, 
  4621.                 this.errorsTrovatiSullaListaEccezioni, this.busta, errore, this.bustaErroreHeaderIntestazione, this.headerEGov, isValido);
  4622.         return result;
  4623.     }
  4624.     
  4625.     @Override
  4626.     public boolean verifyProtocolPresence(TipoPdD tipoPdD, ProfiloDiCollaborazione profilo, RuoloMessaggio ruoloMessaggio,
  4627.             OpenSPCoop2Message msg) throws ProtocolException{
  4628.         if(msg==null){
  4629.             return false;
  4630.         }
  4631.         OpenSPCoop2SoapMessage soap = null;
  4632.         try{
  4633.             soap = msg.castAsSoap();
  4634.         }catch(Exception e){
  4635.             throw new ProtocolException(e.getMessage(),e);
  4636.         }
  4637.         return this.existsHeaderEGov(soap);
  4638.     }

  4640.     @Override
  4641.     public ValidazioneSintatticaResult<SOAPHeaderElement> validazioneManifestAttachments(
  4642.             OpenSPCoop2Message msg,
  4643.             ProprietaManifestAttachments proprietaManifestAttachments) {
  4644.         this.validazioneManifestAttachmentsEGov(msg, proprietaManifestAttachments);
  4645.         ErroreCooperazione errore = null;
  4646.         if(this.msgErrore!=null && this.codiceErrore!=null){
  4647.             errore = new ErroreCooperazione(this.msgErrore, this.codiceErrore);
  4648.         }
  4649.         ValidazioneSintatticaResult<SOAPHeaderElement> result = new ValidazioneSintatticaResult<SOAPHeaderElement>(this.erroriValidazione, this.erroriProcessamento, 
  4650.                 this.errorsTrovatiSullaListaEccezioni, this.busta, errore, this.bustaErroreHeaderIntestazione, this.headerEGov, true);
  4651.         return result;
  4652.     }

  4654.     @Override
  4655.     public SPCoopBustaRawContent getBustaRawContent_senzaControlli(
  4656.             OpenSPCoop2Message msg) throws ProtocolException {
  4657.         try{
  4658.             this.msg = msg.castAsSoap();
  4659.         }catch(Exception e){
  4660.             throw new ProtocolException(e.getMessage(),e);
  4661.         }
  4662.         return this.getHeaderEGov_senzaControlli();
  4663.     }
  4664.     
  4665.     @Override
  4666.     public Busta getBusta_senzaControlli(OpenSPCoop2Message msg) throws ProtocolException{
  4667.         try{
  4668.             this.msg = msg.castAsSoap();
  4669.         }catch(Exception e){
  4670.             throw new ProtocolException(e.getMessage(),e);
  4671.         }
  4672.         if(this.valida(true)){
  4673.             return this.busta;
  4674.         }
  4675.         else{
  4676.             return this.bustaErroreHeaderIntestazione;
  4677.         }
  4678.     }

  4680.     @Override
  4681.     public ValidazioneSintatticaResult<SOAPHeaderElement> validazioneFault(OpenSPCoop2Message msg) {
  4682.         this.validazioneFaultEGov(msg);
  4683.         ErroreCooperazione errore = null;
  4684.         if(this.msgErrore!=null && this.codiceErrore!=null){
  4685.             errore = new ErroreCooperazione(this.msgErrore, this.codiceErrore);
  4686.         }
  4687.         ValidazioneSintatticaResult<SOAPHeaderElement> result = new ValidazioneSintatticaResult<SOAPHeaderElement>(this.erroriValidazione, this.erroriProcessamento, 
  4688.                 this.errorsTrovatiSullaListaEccezioni, this.busta, errore, this.bustaErroreHeaderIntestazione, this.headerEGov, true);
  4689.         return result;
  4690.     }

  4692.     
  4693.     public ProfiloDiCollaborazione toProfilo(String profilo){
  4694.         if(SPCoopCostanti.PROFILO_COLLABORAZIONE_ONEWAY.equals(profilo))
  4695.             return ProfiloDiCollaborazione.ONEWAY;
  4696.         if(SPCoopCostanti.PROFILO_COLLABORAZIONE_SINCRONO.equals(profilo))
  4697.             return ProfiloDiCollaborazione.SINCRONO;
  4698.         if(SPCoopCostanti.PROFILO_COLLABORAZIONE_ASINCRONO_ASIMMETRICO.equals(profilo))
  4699.             return ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO;
  4700.         if(SPCoopCostanti.PROFILO_COLLABORAZIONE_ASINCRONO_SIMMETRICO.equals(profilo))
  4701.             return ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO;
  4702.         return ProfiloDiCollaborazione.UNKNOWN;
  4703.     }
  4704.     public TipoOraRegistrazione toTipoOra(String tipoora){
  4705.         if(SPCoopCostanti.TIPO_TEMPO_LOCALE.equals(tipoora))
  4706.             return TipoOraRegistrazione.LOCALE;
  4707.         if(SPCoopCostanti.TIPO_TEMPO_SPC.equals(tipoora))
  4708.             return TipoOraRegistrazione.SINCRONIZZATO;
  4709.         return TipoOraRegistrazione.UNKNOWN;
  4710.     }
  4711.     public Inoltro toInoltro(String inoltro){
  4712.         if(SPCoopCostanti.PROFILO_TRASMISSIONE_CON_DUPLICATI.equals(inoltro))
  4713.             return Inoltro.CON_DUPLICATI;
  4714.         if(SPCoopCostanti.PROFILO_TRASMISSIONE_SENZA_DUPLICATI.equals(inoltro))
  4715.             return Inoltro.SENZA_DUPLICATI;
  4716.         return Inoltro.UNKNOWN;
  4717.     }
  4718. }
Created with JaCoCo 0.8.8.202204050719