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



  20. package org.openspcoop2.protocol.engine.builder;

  21. import org.openspcoop2.core.constants.TipoPdD;
  22. import org.openspcoop2.core.eccezione.details.DettaglioEccezione;
  23. import org.openspcoop2.core.id.IDServizio;
  24. import org.openspcoop2.core.id.IDSoggetto;
  25. import org.openspcoop2.message.OpenSPCoop2Message;
  26. import org.openspcoop2.message.OpenSPCoop2MessageFactory;
  27. import org.openspcoop2.message.config.ConfigurationRFC7807;
  28. import org.openspcoop2.message.config.IntegrationErrorReturnConfiguration;
  29. import org.openspcoop2.message.constants.MessageType;
  30. import org.openspcoop2.message.exception.ParseException;
  31. import org.openspcoop2.protocol.sdk.AbstractEccezioneBuilderParameter;
  32. import org.openspcoop2.protocol.sdk.Context;
  33. import org.openspcoop2.protocol.sdk.Eccezione;
  34. import org.openspcoop2.protocol.sdk.EccezioneIntegrazioneBuilderParameters;
  35. import org.openspcoop2.protocol.sdk.EccezioneProtocolloBuilderParameters;
  36. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  37. import org.openspcoop2.protocol.sdk.ProtocolException;
  38. import org.openspcoop2.protocol.sdk.builder.IErroreApplicativoBuilder;
  39. import org.openspcoop2.protocol.sdk.builder.ProprietaErroreApplicativo;
  40. import org.openspcoop2.protocol.sdk.config.IProtocolManager;
  41. import org.openspcoop2.protocol.sdk.constants.CodiceErroreIntegrazione;
  42. import org.openspcoop2.protocol.sdk.constants.ErroreIntegrazione;
  43. import org.openspcoop2.protocol.sdk.constants.IntegrationFunctionError;
  44. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  45. import org.openspcoop2.utils.LoggerWrapperFactory;
  46. import org.slf4j.Logger;
  47. import org.w3c.dom.Element;

  48. /**
  49.  * Classe per la gestione degli errori applicativi :
  50.  * <ul>
  51.  * <li> Tracciamento
  52.  * <li> Diagnostica
  53.  * <li> Eccezioni
  54.  * </ul>
  55.  *
  56.  *
  57.  * @author Poli Andrea (apoli@link.it)
  58.  * @author $Author$
  59.  * @version $Rev$, $Date$
  60.  */

  61. public class ErroreApplicativoBuilder  {


  62.     /** Logger utilizzato per debug. */
  63.     protected Logger log = null;
  64.     protected OpenSPCoop2MessageFactory errorFactory = OpenSPCoop2MessageFactory.getDefaultMessageFactory();
  65.     private IProtocolFactory<?> protocolFactory;
  66.     private IProtocolManager protocolManager;
  67.     private IErroreApplicativoBuilder erroreApplicativoBuilder;
  68.     private org.openspcoop2.message.xml.MessageXMLUtils xmlUtils;
  69.     private IDSoggetto dominio;
  70.     public void setDominio(IDSoggetto dominio) {
  71.         this.dominio = dominio;
  72.     }
  73.     private IDSoggetto mittente;
  74.     public void setMittente(IDSoggetto mittente) {
  75.         this.mittente = mittente;
  76.     }
  77.     private IDServizio servizio;
  78.     public void setServizio(IDServizio servizio) {
  79.         this.servizio = servizio;
  80.     }
  81.     private String idFunzione;
  82.     private ProprietaErroreApplicativo proprietaErroreApplicato;
  83.     public void setProprietaErroreApplicato(
  84.             ProprietaErroreApplicativo proprietaErroreApplicato) {
  85.         this.proprietaErroreApplicato = proprietaErroreApplicato;
  86.     }

  87.     private MessageType messageType;
  88.     public MessageType getMessageType() {
  89.         return this.messageType;
  90.     }
  91.    
  92.     private ConfigurationRFC7807 rfc7807;
  93.     private boolean useProblemRFC7807;
  94.     private IntegrationErrorReturnConfiguration returnConfig;
  95.     private IntegrationFunctionError functionError;
  96.     private String nomePorta;
  97.    
  98.     private DettaglioEccezioneOpenSPCoop2Builder dettaglioEccezioneOpenSPCoop2Builder;

  99.     private String servizioApplicativo;
  100.     public void setServizioApplicativo(String servizioApplicativo) {
  101.         this.servizioApplicativo = servizioApplicativo;
  102.     }
  103.    
  104.     private TipoPdD tipoPdD = null;
  105.     public void setTipoPdD(TipoPdD tipoPdD) {
  106.         this.tipoPdD = tipoPdD;
  107.     }
  108.    
  109.     private String idTransazione;
  110.     private Context context;

  111.     public ErroreApplicativoBuilder(Logger aLog, IProtocolFactory<?> protocolFactory,
  112.             IDSoggetto dominio,IDSoggetto mittente,IDServizio servizio,String idFunzione,
  113.             ProprietaErroreApplicativo proprietaErroreApplicativo,MessageType messageType,
  114.             ConfigurationRFC7807 rfc7807, IntegrationErrorReturnConfiguration returnConfig,
  115.             IntegrationFunctionError functionError, String nomePorta,
  116.             TipoPdD tipoPdD,String servizioApplicativo,
  117.             String idTransazione, Context context) throws ProtocolException{
  118.         if(aLog!=null)
  119.             this.log = aLog;
  120.         else
  121.             this.log = LoggerWrapperFactory.getLogger(ErroreApplicativoBuilder.class);
  122.         this.protocolFactory = protocolFactory;
  123.        
  124.         this.xmlUtils = org.openspcoop2.message.xml.MessageXMLUtils.getInstance(this.errorFactory);
  125.        
  126.         this.protocolManager = this.protocolFactory.createProtocolManager();
  127.         this.erroreApplicativoBuilder = this.protocolFactory.createErroreApplicativoBuilder();
  128.        
  129.         this.dominio = dominio;
  130.         this.mittente = mittente;
  131.         this.servizio = servizio;
  132.        
  133.         this.idFunzione = idFunzione;
  134.        
  135.         this.proprietaErroreApplicato = proprietaErroreApplicativo;
  136.        
  137.         this.messageType = messageType;

  138.         this.rfc7807 = rfc7807;
  139.         this.useProblemRFC7807 = this.rfc7807!=null;
  140.         this.returnConfig = returnConfig;
  141.         this.functionError = functionError;
  142.         this.nomePorta = nomePorta;
  143.        
  144.         this.dettaglioEccezioneOpenSPCoop2Builder = new DettaglioEccezioneOpenSPCoop2Builder(aLog, protocolFactory);
  145.        
  146.         this.tipoPdD = tipoPdD;
  147.         this.servizioApplicativo = servizioApplicativo;
  148.        
  149.         this.idTransazione = idTransazione;
  150.        
  151.         this.context = context;
  152.     }

  153.     public IProtocolFactory<?> getProtocolFactory(){
  154.         return this.protocolFactory;
  155.     }
  156.    
  157.     private void setEccezioneBuilderParameter(AbstractEccezioneBuilderParameter parameters,
  158.             DettaglioEccezione dettaglio, ParseException parseException){
  159.        
  160.         parameters.setDettaglioEccezionePdD(dettaglio);
  161.        
  162.         parameters.setDominioPorta(this.dominio);
  163.         parameters.setMittente(this.mittente);
  164.         parameters.setServizio(this.servizio);
  165.        
  166.         parameters.setIdFunzione(this.idFunzione);
  167.        
  168.         parameters.setProprieta(this.proprietaErroreApplicato);
  169.        
  170.         parameters.setMessageType(this.messageType);
  171.        
  172.         parameters.setRfc7807(this.rfc7807);
  173.         parameters.setReturnConfig(this.returnConfig);
  174.         parameters.setFunctionError(this.functionError);
  175.        
  176.         parameters.setNomePorta(this.nomePorta);
  177.         if(this.nomePorta==null) {
  178.             if(this.context!=null && this.context.containsKey(org.openspcoop2.core.constants.Costanti.REQUEST_INFO)) {
  179.                 Object o = this.context.getObject(org.openspcoop2.core.constants.Costanti.REQUEST_INFO);
  180.                 if(o!=null && o instanceof RequestInfo) {
  181.                     RequestInfo requestInfo = (RequestInfo) o;
  182.                     if(requestInfo.getProtocolContext()!=null) {
  183.                         this.nomePorta = requestInfo.getProtocolContext().getInterfaceName();
  184.                     }
  185.                 }
  186.             }
  187.         }
  188.        
  189.         parameters.setTransactionId(this.idTransazione);
  190.         parameters.setContext(this.context);
  191.        
  192.         parameters.setTipoPorta(this.tipoPdD);
  193.        
  194.         parameters.setServizioApplicativo(this.servizioApplicativo);
  195.        
  196.         parameters.setParseException(parseException);
  197.        
  198.     }
  199.    
  200.     private EccezioneProtocolloBuilderParameters getEccezioneProtocolloBuilderParameters(
  201.             Eccezione eccezioneProtocollo,IDSoggetto soggettoProduceEccezione,
  202.             DettaglioEccezione dettaglio, ParseException parseException){
  203.        
  204.         EccezioneProtocolloBuilderParameters parameters = new EccezioneProtocolloBuilderParameters();
  205.        
  206.         this.setEccezioneBuilderParameter(parameters, dettaglio, parseException);
  207.        
  208.         parameters.setEccezioneProtocollo(eccezioneProtocollo);
  209.         parameters.setSoggettoProduceEccezione(soggettoProduceEccezione);

  210.         return parameters;
  211.     }
  212.    
  213.     private EccezioneIntegrazioneBuilderParameters getEccezioneIntegrazioneBuilderParameters(
  214.             ErroreIntegrazione erroreIntegrazione,
  215.             DettaglioEccezione dettaglio, ParseException parseException){
  216.        
  217.         EccezioneIntegrazioneBuilderParameters parameters = new EccezioneIntegrazioneBuilderParameters();
  218.                
  219.         this.setEccezioneBuilderParameter(parameters, dettaglio, parseException);
  220.        
  221.         parameters.setErroreIntegrazione(erroreIntegrazione);
  222.        
  223.         return parameters;
  224.     }
  225.    
  226.    
  227.    
  228.    
  229.    
  230.    
  231.    
  232.    
  233.    
  234.     /* ---------------- MESSAGGI DI ERRORE APPLICATIVO --------------------- */

  235.     public Element toElement(ErroreIntegrazione errore)throws ProtocolException{
  236.         EccezioneIntegrazioneBuilderParameters parameters =
  237.             this.getEccezioneIntegrazioneBuilderParameters(errore, null, null);
  238.         return this.erroreApplicativoBuilder.toElement(parameters);
  239.     }

  240.     public byte[] toByteArray(ErroreIntegrazione errore) throws ProtocolException{
  241.         Element eccezione = this.toElement(errore);
  242.         if(eccezione == null){
  243.             throw new ProtocolException("Elemento non generato");
  244.         }
  245.         try{
  246.             return this.xmlUtils.toByteArray(eccezione,true);
  247.         } catch(Exception e) {
  248.             this.log.error("XMLBuilder.buildBytes_Eccezione error: "+e.getMessage(),e);
  249.             throw new ProtocolException("toByte failed: "+e.getMessage(),e);
  250.         }
  251.     }


  252.    
  253.    
  254.     /* ---------------- UTILITY PER L'INSERIMENTO DEL MSG DI ERRORE APPLICATIVO NEI DETAILS DI UN SOAP FAULT --------------------- */

  255.     public void insertInSOAPFault(ErroreIntegrazione errore,
  256.             OpenSPCoop2Message msg) throws ProtocolException{
  257.         EccezioneIntegrazioneBuilderParameters parameters =
  258.             this.getEccezioneIntegrazioneBuilderParameters(errore, null, null);
  259.         this.erroreApplicativoBuilder.insertInSOAPFault(parameters, msg);
  260.     }
  261.    
  262.     public void insertRoutingErrorInSOAPFault(IDSoggetto identitaRouter,String idFunzione,String msgErrore,OpenSPCoop2Message msg) throws ProtocolException{
  263.         this.erroreApplicativoBuilder.insertRoutingErrorInSOAPFault(identitaRouter, idFunzione,msgErrore,msg);
  264.     }  
  265.    




  266.     /* ---------------- UTILITY PER LA COSTRUZIONE DI MESSAGGI DI ERRORE APPLICATIVO --------------------- */
  267.     public OpenSPCoop2Message toMessage(ErroreIntegrazione errore,
  268.             Throwable eProcessamento, ParseException parseException){
  269.         try{
  270.            
  271.             boolean produciDettaglioEccezione = false;
  272.             if(errore.getCodiceErrore().getCodice() < 500 &&
  273.                     CodiceErroreIntegrazione.CODICE_5XX_CUSTOM.getCodice()!=errore.getCodiceErrore().getCodice()){ // CODICE_5XX_CUSTOM = 5
  274.                 produciDettaglioEccezione = this.protocolManager.isGenerazioneDetailsFaultIntegratione_erroreClient();
  275.             }else{
  276.                 produciDettaglioEccezione = this.protocolManager.isGenerazioneDetailsFaultIntegratione_erroreServer();
  277.             }
  278.            
  279.             // uso byte per avere eraser type...
  280.             String msgErroreTrasformato = this.proprietaErroreApplicato.transformFaultMsg(errore,this.protocolFactory);
  281.             String codErroreTrasformato = this.protocolFactory.createTraduttore().
  282.                     toCodiceErroreIntegrazioneAsString(errore, this.proprietaErroreApplicato.getFaultPrefixCode(),
  283.                                                        this.proprietaErroreApplicato.isFaultAsGenericCode());
  284.                
  285.             // Creo Dettaglio Eccezione
  286.             DettaglioEccezione dettaglioEccezione = null;
  287.             if(produciDettaglioEccezione){
  288.                
  289.                 dettaglioEccezione = this.dettaglioEccezioneOpenSPCoop2Builder.buildDettaglioEccezione(this.dominio, this.tipoPdD, this.idFunzione,
  290.                         codErroreTrasformato, msgErroreTrasformato, false,
  291.                         this.returnConfig, this.functionError);
  292.                 if(eProcessamento!=null){
  293.                     // internamente, se l'informazioni sul details di OpenSPCoop non e' definita viene usato come comportamento quello del servizio applicativo
  294.                     boolean informazioniGeneriche = this.proprietaErroreApplicato.isInformazioniGenericheDetailsOpenSPCoop();
  295.                     this.dettaglioEccezioneOpenSPCoop2Builder.gestioneDettaglioEccezioneIntegrazione(eProcessamento, dettaglioEccezione, informazioniGeneriche);
  296.                 }
  297.             }
  298.            
  299.             EccezioneIntegrazioneBuilderParameters parameters =
  300.                 this.getEccezioneIntegrazioneBuilderParameters(errore, dettaglioEccezione, parseException);
  301.             OpenSPCoop2Message msg = this.erroreApplicativoBuilder.toMessage(parameters);
  302.            
  303.             return msg;
  304.         }catch(Exception e){
  305.             this.log.error("Errore durante la costruzione del messaggio di eccezione integrazione",e);
  306.             return this.errorFactory.createFaultMessage(this.messageType, this.useProblemRFC7807, "ErroreDiProcessamento");
  307.         }
  308.     }

  309.     public OpenSPCoop2Message toMessage(Eccezione eccezione,IDSoggetto soggettoProduceEccezione, ParseException parseException){
  310.         return toMessage(eccezione, soggettoProduceEccezione, null, parseException);
  311.     }
  312.    
  313.     public OpenSPCoop2Message toMessage(Eccezione eccezione,IDSoggetto soggettoProduceEccezione,DettaglioEccezione dettaglioEccezione, ParseException parseException){
  314.         try{
  315.             EccezioneProtocolloBuilderParameters parameters =
  316.                 this.getEccezioneProtocolloBuilderParameters(eccezione, soggettoProduceEccezione, dettaglioEccezione, parseException);
  317.             return this.erroreApplicativoBuilder.toMessage(parameters);
  318.         } catch (Exception e) {
  319.             this.log.error("Errore durante la costruzione del messaggio di eccezione busta",e);
  320.             return this.errorFactory.createFaultMessage(this.messageType, this.useProblemRFC7807, "ErroreDiProcessamento");
  321.         }
  322.     }

  323.    
  324. }