SDIBustaBuilder.java

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

  21. package org.openspcoop2.protocol.sdi.builder;

  23. import it.gov.fatturapa.sdi.messaggi.v1_0.constants.TipiMessaggi;

  25. import javax.xml.soap.SOAPElement;

  27. import org.openspcoop2.message.OpenSPCoop2Message;
  28. import org.openspcoop2.message.OpenSPCoop2SoapMessage;
  29. import org.openspcoop2.message.config.ServiceBindingConfiguration;
  30. import org.openspcoop2.message.constants.ServiceBinding;
  31. import org.openspcoop2.protocol.basic.builder.BustaBuilder;
  32. import org.openspcoop2.protocol.sdi.SDIBustaRawContent;
  33. import org.openspcoop2.protocol.sdi.config.SDIProperties;
  34. import org.openspcoop2.protocol.sdi.constants.SDICostantiServizioRiceviFile;
  35. import org.openspcoop2.protocol.sdi.constants.SDICostantiServizioRiceviNotifica;
  36. import org.openspcoop2.protocol.sdi.constants.SDICostantiServizioRicezioneFatture;
  37. import org.openspcoop2.protocol.sdi.constants.SDICostantiServizioTrasmissioneFatture;
  38. import org.openspcoop2.protocol.sdk.Busta;
  39. import org.openspcoop2.protocol.sdk.Context;
  40. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  41. import org.openspcoop2.protocol.sdk.ProtocolException;
  42. import org.openspcoop2.protocol.sdk.ProtocolMessage;
  43. import org.openspcoop2.protocol.sdk.builder.ProprietaManifestAttachments;
  44. import org.openspcoop2.protocol.sdk.constants.FaseImbustamento;
  45. import org.openspcoop2.protocol.sdk.constants.FaseSbustamento;
  46. import org.openspcoop2.protocol.sdk.constants.RuoloMessaggio;
  47. import org.openspcoop2.protocol.sdk.state.IState;

  49. /**
  50.  * Classe che implementa, in base al protocollo SdI, l'interfaccia {@link org.openspcoop2.protocol.sdk.builder.IBustaBuilder} 
  51.  *
  52.  * @author Poli Andrea (apoli@link.it)
  53.  * @author $Author$
  54.  * @version $Rev$, $Date$
  55.  */
  56. public class SDIBustaBuilder extends BustaBuilder<SOAPElement> {

  58.     /** Properties */
  59.     protected SDIProperties sdiProperties;
  60.     /** SDIImbustamento */
  61.     private SDIImbustamento sdiImbustamento;
  62.     /** SDISbustamento */
  63.     private SDISbustamento sdiSbustamento;
  64.     
  65.     public SDIBustaBuilder(IProtocolFactory<SOAPElement> factory, IState state) throws ProtocolException {
  66.         super(factory, state);
  67.         this.sdiProperties = SDIProperties.getInstance(this.log);
  68.         this.sdiImbustamento = new SDIImbustamento(this);
  69.         this.sdiSbustamento = new SDISbustamento(this);
  70.     }

  72.     @Override
  73.     public ProtocolMessage imbustamento(OpenSPCoop2Message msg, Context context,
  74.             Busta busta, Busta bustaRichiesta,
  75.             RuoloMessaggio ruoloMessaggio,
  76.             ProprietaManifestAttachments proprietaManifestAttachments,
  77.             FaseImbustamento faseImbustamento)
  78.             throws ProtocolException {
  79.         
  80.         if(FaseImbustamento.DOPO_SICUREZZA_MESSAGGIO.equals(faseImbustamento)) {
  81.             ProtocolMessage protocolMessage = new ProtocolMessage();
  82.             protocolMessage.setPhaseUnsupported(true);
  83.             return protocolMessage;
  84.         }
  85.         
  86.         ProtocolMessage protocolMessage = super.imbustamento(msg, context,
  87.                 busta, bustaRichiesta,
  88.                 ruoloMessaggio, proprietaManifestAttachments, faseImbustamento);
  89.         
  90.         // Modifico il messaggio per aggiungere la struttura SDI in base all'azione invocata e al ruolo (Richiesta/Risposta) e al fatto che non vi sono errori.
  91.         // TODO: il body attuale lo devo inserire come valore codificato in base 64 tramite la struttura Corretta
  92.         // Forse è utile in questo contesto generare gli elementi con jaxb.
  93.         // Dopo configuro il packaging di MTOM
  94.         
  95.         // Check Destinatario
  96.         if(busta.getTipoDestinatario().equals(this.sdiProperties.getTipoSoggettoSDI())==false){
  97.             throw new ProtocolException("TipoDestinatario["+busta.getTipoDestinatario()+"] differente da quello atteso per il Sistema di Interscambio ["+this.sdiProperties.getTipoSoggettoSDI()+"]");
  98.         }
  99.         if(busta.getDestinatario().equals(this.sdiProperties.getNomeSoggettoSDI())==false){
  100.             boolean whiteList = false;
  101.             if(busta.getDestinatario()!=null && this.sdiProperties.getSoggettiWhiteList().contains(busta.getDestinatario())){
  102.                 this.log.debug("Destinatario ["+busta.getDestinatario()+"] in white list");
  103.                 whiteList = true;
  104.             }
  105.             if(!whiteList){
  106.                 throw new ProtocolException("NomeDestinatario["+busta.getDestinatario()+"] differente da quello atteso per il Sistema di Interscambio ["+this.sdiProperties.getNomeSoggettoSDI()+"]");
  107.             }
  108.         }
  109.         
  110.         SOAPElement element = null;
  111.         
  112.         if(RuoloMessaggio.RICHIESTA.equals(ruoloMessaggio)){
  113.     
  114.             // Servizio
  115.             if(SDICostantiServizioRiceviFile.SDI_SERVIZIO_RICEVI_FILE.equals(busta.getServizio())
  116.                     && SDICostantiServizioRiceviFile.SDI_SERVIZIO_RICEVI_FILE_AZIONE_RICEVI_FILE.equals(busta.getAzione())){
  117.                 element = this.sdiImbustamento.creaRichiesta_ServizioSdIRiceviFile_AzioneRiceviFile(this.protocolFactory, this.state, busta, msg);
  118.             }
  119.             else if(SDICostantiServizioRiceviNotifica.SDI_SERVIZIO_RICEVI_NOTIFICA.equals(busta.getServizio())
  120.                     && SDICostantiServizioRiceviNotifica.SDI_SERVIZIO_NOTIFICA_ESITO_AZIONE_NOTIFICA_ESITO.equals(busta.getAzione())){
  121.                 element = this.sdiImbustamento.creaRichiesta_ServizioSdIRiceviNotifica_AzioneNotificaEsito(this.protocolFactory,this.state,busta,msg,
  122.                         this.sdiProperties.isEnableGenerazioneMessaggiCompatibilitaNamespaceSenzaGov(),
  123.                         this.sdiProperties.isEnableValidazioneMessaggiCompatibilitaNamespaceSenzaGov());
  124.             }
  125.             else{
  126.                 boolean whiteList = false;
  127.                 if(busta.getServizio()!=null && this.sdiProperties.getServiziWhiteList().contains(busta.getServizio())){
  128.                     if(busta.getAzione()!=null && this.sdiProperties.getAzioniWhiteList().contains(busta.getAzione())){
  129.                         this.log.debug("Servizio ["+busta.getServizio()+"] e Azione ["+busta.getAzione()+"] in white list");
  130.                         whiteList = true;
  131.                     }
  132.                 }
  133.                 if(!whiteList){
  134.                     throw new ProtocolException("Servizio["+busta.getServizio()+"] e Azione["+busta.getAzione()+"] non gestite dal protocollo durante la fase di richiesta");
  135.                 }
  136.             }
  137.             
  138.         }
  139.         else{
  140.             if(busta.sizeListaEccezioni()>0){
  141.                 
  142.                 // le eccezioni vengono tornate anche per gli errori di processamento poiche' in TrasparenteProtocolVersionManager
  143.                 // e' stato cablato il metodo isGenerazioneListaEccezioniErroreProcessamento al valore 'true'
  144.                 
  145.                 // Per quanto riguarda la generazione dei codici SOAPFault personalizzati e/o la generazione dell'elemento errore-applicativo
  146.                 // la scelta e' delegata a due proprieta' nel file di proprieta'.
  147.                 //
  148.                 // Infine la scelta della presenza o meno dell'elemento OpenSPCoop2Details lo stesso viene pilotata dalle proprieta' presenti nel file di proprieta'
  149.                 
  150.                 boolean ignoraEccezioniNonGravi = this.protocolFactory.createProtocolManager().isIgnoraEccezioniNonGravi();
  151.                 if(ignoraEccezioniNonGravi){
  152.                     if(busta.containsEccezioniGravi() ){
  153.                         this.enrichFault(msg, busta, ignoraEccezioniNonGravi,
  154.                                 this.sdiProperties.isPortaApplicativaBustaErrore_personalizzaElementiFault(),
  155.                                 this.sdiProperties.isPortaApplicativaBustaErrore_aggiungiErroreApplicativo());
  156.                     }   
  157.                 }
  158.                 else{
  159.                     this.enrichFault(msg, busta, ignoraEccezioniNonGravi,
  160.                             this.sdiProperties.isPortaApplicativaBustaErrore_personalizzaElementiFault(),
  161.                             this.sdiProperties.isPortaApplicativaBustaErrore_aggiungiErroreApplicativo());
  162.                 }
  163.             }
  164.             
  165.             try{
  166.                 OpenSPCoop2SoapMessage soapMsg = msg.castAsSoap();
  167.                 if(soapMsg.getSOAPBody()!=null && soapMsg.getSOAPBody().hasFault()){
  168.                     return null;
  169.                 }
  170.             }catch(Exception e){
  171.                 throw new ProtocolException(e.getMessage(),e);
  172.             }
  173.             
  174.             // Servizio
  175.             if(SDICostantiServizioRicezioneFatture.RICEZIONE_SERVIZIO_RICEZIONE_FATTURE.equals(busta.getServizio())
  176.                     && SDICostantiServizioRicezioneFatture.RICEZIONE_SERVIZIO_RICEZIONE_FATTURE_AZIONE_RICEVI_FATTURE.equals(busta.getAzione())){
  177.                 element = this.sdiImbustamento.creaRisposta_ServizioRicezioneFatture_AzioneRiceviFatture(this.protocolFactory,this.state,busta,msg);
  178.             }
  179.             else{
  180.                 boolean whiteList = false;
  181.                 if(busta.getServizio()!=null && this.sdiProperties.getServiziWhiteList().contains(busta.getServizio())){
  182.                     if(busta.getAzione()!=null && this.sdiProperties.getAzioniWhiteList().contains(busta.getAzione())){
  183.                         this.log.debug("Servizio ["+busta.getServizio()+"] e Azione ["+busta.getAzione()+"] in white list");
  184.                         whiteList = true;
  185.                     }
  186.                 }
  187.                 if(!whiteList){
  188.                     throw new ProtocolException("Servizio["+busta.getServizio()+"] e Azione["+busta.getAzione()+"] non gestite dal protocollo durante la fase di risposta");
  189.                 }
  190.             }
  191.             
  192.         }

  194.         if(element!=null) {
  195.             protocolMessage.setBustaRawContent(new SDIBustaRawContent(element));
  196.         }
  197.         return protocolMessage;
  198.         
  199.     }
  200.     
  201.     @Override
  202.     public ProtocolMessage sbustamento(OpenSPCoop2Message msg, Context context,
  203.             Busta busta,
  204.             RuoloMessaggio ruoloMessaggio, ProprietaManifestAttachments proprietaManifestAttachments,
  205.             FaseSbustamento faseSbustamento, ServiceBinding integrationServiceBinding, ServiceBindingConfiguration serviceBindingConfiguration) throws ProtocolException{
  206.         
  207.         try{
  208.         
  209.             ProtocolMessage protocolMessage = new ProtocolMessage();
  210.             protocolMessage.setMessage(msg);
  211.             
  212.             if(FaseSbustamento.POST_VALIDAZIONE_SEMANTICA_RICHIESTA.equals(faseSbustamento) == false &&
  213.                     FaseSbustamento.POST_VALIDAZIONE_SEMANTICA_RISPOSTA.equals(faseSbustamento) == false){
  214.                 
  215.                 // Lo sbustamento effettivo in sdi viene ritardato fino alla consegna del servizio applicativo
  216.                 // il servizio applicativo può richiederlo di non effettuarlo
  217.                 SOAPElement se = null;
  218.                         
  219.                 if(RuoloMessaggio.RICHIESTA.equals(ruoloMessaggio)){
  220.                     
  221.                     // Servizio
  222.                     if(SDICostantiServizioTrasmissioneFatture.TRASMISSIONE_SERVIZIO_TRASMISSIONE_FATTURE.equals(busta.getServizio())){
  223.                         if(SDICostantiServizioTrasmissioneFatture.TRASMISSIONE_SERVIZIO_TRASMISSIONE_FATTURE_AZIONE_RICEVUTA_CONSEGNA.equals(busta.getAzione())){
  224.                             se = this.sdiSbustamento.sbustamentoRichiesta_ServizioTrasmissioneFatture_Notifiche(TipiMessaggi.RC, busta, msg);
  225.                         }
  226.                         else if(SDICostantiServizioTrasmissioneFatture.TRASMISSIONE_SERVIZIO_TRASMISSIONE_FATTURE_AZIONE_NOTIFICA_MANCATA_CONSEGNA.equals(busta.getAzione())){
  227.                             se = this.sdiSbustamento.sbustamentoRichiesta_ServizioTrasmissioneFatture_Notifiche(TipiMessaggi.MC, busta, msg);
  228.                         }
  229.                         else if(SDICostantiServizioTrasmissioneFatture.TRASMISSIONE_SERVIZIO_TRASMISSIONE_FATTURE_AZIONE_NOTIFICA_SCARTO.equals(busta.getAzione())){
  230.                             se = this.sdiSbustamento.sbustamentoRichiesta_ServizioTrasmissioneFatture_Notifiche(TipiMessaggi.NS, busta, msg);
  231.                         }
  232.                         else if(SDICostantiServizioTrasmissioneFatture.TRASMISSIONE_SERVIZIO_TRASMISSIONE_FATTURE_AZIONE_NOTIFICA_ESITO.equals(busta.getAzione())){
  233.                             se = this.sdiSbustamento.sbustamentoRichiesta_ServizioTrasmissioneFatture_Notifiche(TipiMessaggi.NE, busta, msg);
  234.                         }
  235.                         else if(SDICostantiServizioTrasmissioneFatture.TRASMISSIONE_SERVIZIO_TRASMISSIONE_FATTURE_AZIONE_NOTIFICA_DECORRENZA_TERMINI.equals(busta.getAzione())){
  236.                             se = this.sdiSbustamento.sbustamentoRichiesta_ServizioTrasmissioneFatture_Notifiche(TipiMessaggi.DT, busta, msg);
  237.                         }
  238.                         else if(SDICostantiServizioTrasmissioneFatture.TRASMISSIONE_SERVIZIO_TRASMISSIONE_FATTURE_AZIONE_ATTESTAZIONE_TRASMISSIONE_FATTURA.equals(busta.getAzione())){
  239.                             se = this.sdiSbustamento.sbustamentoRichiesta_ServizioTrasmissioneFatture_Notifiche(TipiMessaggi.AT, busta, msg);
  240.                         }
  241.                         else{
  242.                             throw new ProtocolException("Servizio["+busta.getServizio()+"] con Azione["+busta.getAzione()+"] non gestita dal protocollo durante la fase di richiesta");
  243.                         }
  244.                     }
  245.                     else if(SDICostantiServizioRicezioneFatture.RICEZIONE_SERVIZIO_RICEZIONE_FATTURE.equals(busta.getServizio())){
  246.                         if(SDICostantiServizioRicezioneFatture.RICEZIONE_SERVIZIO_RICEZIONE_FATTURE_AZIONE_RICEVI_FATTURE.equals(busta.getAzione())){
  247.                             se = this.sdiSbustamento.sbustamentoRichiesta_ServizioRicezioneFatture_AzioneRiceviFatture(busta, msg);
  248.                         }
  249.                         else if(SDICostantiServizioRicezioneFatture.RICEZIONE_SERVIZIO_RICEZIONE_FATTURE_AZIONE_NOTIFICA_DECORRENZA_TERMINI.equals(busta.getAzione())){
  250.                             se = this.sdiSbustamento.sbustamentoRichiesta_ServizioTrasmissioneFatture_Notifiche(TipiMessaggi.DT, busta, msg); // e' uguale a ricezione
  251.                         }
  252.                         else{
  253.                             throw new ProtocolException("Servizio["+busta.getServizio()+"] con Azione["+busta.getAzione()+"] non gestita dal protocollo durante la fase di richiesta");
  254.                         }
  255.                     }
  256.                     else{
  257.                         boolean whiteList = false;
  258.                         if(busta.getServizio()!=null && this.sdiProperties.getServiziWhiteList().contains(busta.getServizio())){
  259.                             if(busta.getAzione()!=null && this.sdiProperties.getAzioniWhiteList().contains(busta.getAzione())){
  260.                                 this.log.debug("Servizio ["+busta.getServizio()+"] e Azione ["+busta.getAzione()+"] in white list");
  261.                                 whiteList = true;
  262.                             }
  263.                         }
  264.                         if(!whiteList){
  265.                             throw new ProtocolException("Servizio["+busta.getServizio()+"] non gestite dal protocollo durante la fase di richiesta");
  266.                         }
  267.                     }
  268.                     
  269.                 }
  270.                 else{
  271.         
  272.                     // Servizio
  273.                     if(SDICostantiServizioRiceviFile.SDI_SERVIZIO_RICEVI_FILE.equals(busta.getServizio())
  274.                             && SDICostantiServizioRiceviFile.SDI_SERVIZIO_RICEVI_FILE_AZIONE_RICEVI_FILE.equals(busta.getAzione())){
  275.                         se = this.sdiSbustamento.sbustamentoRisposta_ServizioSdIRiceviFile_AzioneRiceviFile(busta, msg);
  276.                     }
  277.                     else if(SDICostantiServizioRiceviNotifica.SDI_SERVIZIO_RICEVI_NOTIFICA.equals(busta.getServizio())
  278.                             && SDICostantiServizioRiceviNotifica.SDI_SERVIZIO_NOTIFICA_ESITO_AZIONE_NOTIFICA_ESITO.equals(busta.getAzione())){
  279.                         se = this.sdiSbustamento.sbustamentoRisposta_ServizioSdIRiceviNotifica_AzioneNotificaEsito(busta, msg);
  280.                     }
  281.                     else{
  282.                         boolean whiteList = false;
  283.                         if(busta.getServizio()!=null && this.sdiProperties.getServiziWhiteList().contains(busta.getServizio())){
  284.                             if(busta.getAzione()!=null && this.sdiProperties.getAzioniWhiteList().contains(busta.getAzione())){
  285.                                 this.log.debug("Servizio ["+busta.getServizio()+"] e Azione ["+busta.getAzione()+"] in white list");
  286.                                 whiteList = true;
  287.                             }
  288.                         }
  289.                         if(!whiteList){
  290.                             throw new ProtocolException("Servizio["+busta.getServizio()+"] e Azione["+busta.getAzione()+"] non gestite dal protocollo durante la fase di risposta");
  291.                         }
  292.                     }
  293.                     
  294.                 }
  295.                 
  296.                 if(se!=null) {
  297.                     protocolMessage.setBustaRawContent(new SDIBustaRawContent(se));
  298.                 }
  299.                 protocolMessage.setMessage(msg);
  300.             }
  301.             
  302.             return protocolMessage;
  303.             
  304.         }catch(Exception e){
  305.             throw new ProtocolException(e.getMessage(),e);
  306.         }
  307.         
  308.     }
  309.     
  310. }
Created with JaCoCo 0.8.8.202204050719