BustaBuilder.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.basic.builder;

  23. import java.text.SimpleDateFormat;
  24. import java.util.Date;
  25. import java.util.Iterator;

  27. import javax.xml.namespace.QName;
  28. import javax.xml.soap.SOAPFault;

  30. import org.openspcoop2.core.constants.TipoPdD;
  31. import org.openspcoop2.core.id.IDServizio;
  32. import org.openspcoop2.core.id.IDSoggetto;
  33. import org.openspcoop2.core.registry.driver.IDServizioFactory;
  34. import org.openspcoop2.message.OpenSPCoop2Message;
  35. import org.openspcoop2.message.OpenSPCoop2SoapMessage;
  36. import org.openspcoop2.message.config.ServiceBindingConfiguration;
  37. import org.openspcoop2.message.constants.ServiceBinding;
  38. import org.openspcoop2.message.soap.SOAPFaultCode;
  39. import org.openspcoop2.protocol.basic.BasicStateComponentFactory;
  40. import org.openspcoop2.protocol.basic.Costanti;
  41. import org.openspcoop2.protocol.sdk.Busta;
  42. import org.openspcoop2.protocol.sdk.Context;
  43. import org.openspcoop2.protocol.sdk.Eccezione;
  44. import org.openspcoop2.protocol.sdk.EccezioneProtocolloBuilderParameters;
  45. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  46. import org.openspcoop2.protocol.sdk.ProtocolException;
  47. import org.openspcoop2.protocol.sdk.ProtocolMessage;
  48. import org.openspcoop2.protocol.sdk.Riscontro;
  49. import org.openspcoop2.protocol.sdk.Trasmissione;
  50. import org.openspcoop2.protocol.sdk.builder.IErroreApplicativoBuilder;
  51. import org.openspcoop2.protocol.sdk.builder.ProprietaManifestAttachments;
  52. import org.openspcoop2.protocol.sdk.config.ITraduttore;
  53. import org.openspcoop2.protocol.sdk.constants.ErroriCooperazione;
  54. import org.openspcoop2.protocol.sdk.constants.FaseImbustamento;
  55. import org.openspcoop2.protocol.sdk.constants.FaseSbustamento;
  56. import org.openspcoop2.protocol.sdk.constants.Inoltro;
  57. import org.openspcoop2.protocol.sdk.constants.LivelloRilevanza;
  58. import org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione;
  59. import org.openspcoop2.protocol.sdk.constants.RuoloMessaggio;
  60. import org.openspcoop2.protocol.sdk.constants.TipoOraRegistrazione;
  61. import org.openspcoop2.protocol.sdk.state.IState;
  62. import org.openspcoop2.utils.date.DateManager;
  63. import org.openspcoop2.utils.date.DateUtils;
  64. import org.openspcoop2.utils.id.UniqueIdentifierManager;

  66. /** 
  67.  * BustaBuilder
  68.  *
  69.  * @author Poli Andrea (apoli@link.it)
  70.  * @author $Author$
  71.  * @version $Rev$, $Date$
  72.  */
  73. public class BustaBuilder<BustaRawType> extends BasicStateComponentFactory implements org.openspcoop2.protocol.sdk.builder.IBustaBuilder<BustaRawType> {
  74.     
  75.     protected ITraduttore traduttore;
  76.     protected IErroreApplicativoBuilder erroreApplicativoBuilder = null;
  77.         
  78.     public BustaBuilder(IProtocolFactory<?> factory, IState state) throws ProtocolException{
  79.         super(factory,state);
  80.         this.traduttore = this.protocolFactory.createTraduttore();
  81.         this.erroreApplicativoBuilder = this.protocolFactory.createErroreApplicativoBuilder();
  82.     }

  84.     private static final String dateformatPattern = "yyyyMMddHHmmssSSS"; // utile per il filtro duplicati
  85.     
  86.     @Override
  87.     public String newID(IDSoggetto idSoggetto, String idTransazione, RuoloMessaggio ruoloMessaggio) throws ProtocolException {
  88.         return newID(idSoggetto, idTransazione, ruoloMessaggio, true);
  89.     }
  90.     public String newID(IDSoggetto idSoggetto, String idTransazione, RuoloMessaggio ruoloMessaggio, boolean generateIDasUUID) throws ProtocolException {
  91.         
  92.         if(generateIDasUUID){
  93.             
  94.             try{
  95.                 return UniqueIdentifierManager.newUniqueIdentifier().getAsString();
  96.             }catch(Exception e){
  97.                 throw new ProtocolException(e.getMessage());
  98.             }
  99.             
  100.         }
  101.         else{
  102.         
  103.             String id = idTransazione;
  104.             
  105.     //      try {
  106.     //          XMLGregorianCalendar cal = DatatypeFactory.newInstance().newXMLGregorianCalendar(new GregorianCalendar());
  107.     //          id = id + "_T_" + cal.getSecond() + cal.getMillisecond();
  108.     //      } catch (DatatypeConfigurationException e) {
  109.     //          throw new ProtocolException(e);
  110.     //      }
  111.             
  112.             Date now = DateManager.getDate();
  113.             
  114.             // NOTA: La data nell'identificativo e' utile quando l'id viene usato in un filtro duplicati
  115.             //       Per avere un insieme di identificativi in ordine raggruppate per date. (aiuta l'indice sulla base dati)
  116.             //       Essendo questa una classe di base si preferisce aggiungere la data. 
  117.             //       Se non la si vuole nel protocollo trasparente reimplementare questo metodo nel protocollo trasparente eliminando la data
  118.             //       Anche il metodo extractDate dovra' a quel punto essere reimplementato ritornando null
  119.             
  120.             SimpleDateFormat dateFormat = DateUtils.getDefaultDateTimeFormatter(dateformatPattern);
  121.             
  122.             if(RuoloMessaggio.RICHIESTA.equals(ruoloMessaggio))
  123.     //          return id+ "-request";
  124.                 return dateFormat.format(now)+"-"+id;
  125.             else
  126.                 return dateFormat.format(now)+"-"+id + "-response";
  127.             
  128.         }
  129.     }

  131.     @Override
  132.     public Date extractDateFromID(String id) throws ProtocolException {
  133.         return this.extractDateFromID(id, true);
  134.     }
  135.     public Date extractDateFromID(String id, boolean generateIDasUUID) throws ProtocolException {
  136.         if(id==null){
  137.             throw new ProtocolException("ID non fornito");
  138.         }
  139.         if(generateIDasUUID == false){
  140.             if(id.contains("-")==false){
  141.                 throw new ProtocolException("ID fornito ["+id+"] non e' corretto (missing '-')");
  142.             }
  143.             String [] split = id.split("-");
  144.             
  145.             SimpleDateFormat dateFormat = DateUtils.getDefaultDateTimeFormatter(dateformatPattern);
  146.             
  147.             try{
  148.                 return dateFormat.parse(split[0].trim());
  149.             }catch(Exception e){
  150.                 throw new ProtocolException("ID fornito ["+id+"] non e' corretto: "+e.getMessage());
  151.             }
  152.         }
  153.         else{
  154.             return null;
  155.         }
  156.     }
  157.     

  159.     
  160.     @Override
  161.     public ProtocolMessage imbustamento(OpenSPCoop2Message msg, Context context,
  162.             Busta busta, Busta bustaRichiesta,
  163.             RuoloMessaggio ruoloMessaggio,
  164.             ProprietaManifestAttachments proprietaManifestAttachments,
  165.             FaseImbustamento faseImbustamento)
  166.             throws ProtocolException {
  167.         
  168.         if(FaseImbustamento.DOPO_SICUREZZA_MESSAGGIO.equals(faseImbustamento)) {
  169.             ProtocolMessage protocolMessage = new ProtocolMessage();
  170.             protocolMessage.setPhaseUnsupported(true);
  171.             return protocolMessage;
  172.         }
  173.         
  174.         if(busta.getProfiloDiCollaborazione() != null) {
  175.             switch (busta.getProfiloDiCollaborazione()) {
  176.             case ONEWAY:
  177.                 busta.setProfiloDiCollaborazione(ProfiloDiCollaborazione.ONEWAY, ProfiloDiCollaborazione.ONEWAY.getEngineValue());
  178.                 break;
  179.             case SINCRONO:
  180.                 busta.setProfiloDiCollaborazione(ProfiloDiCollaborazione.SINCRONO, ProfiloDiCollaborazione.SINCRONO.getEngineValue());
  181.                 break;
  182.             case ASINCRONO_ASIMMETRICO:
  183.                 busta.setProfiloDiCollaborazione(ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO, ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO.getEngineValue());
  184.                 break;
  185.             case ASINCRONO_SIMMETRICO:
  186.                 busta.setProfiloDiCollaborazione(ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO, ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO.getEngineValue());
  187.                 break;
  188.             case UNKNOWN:
  189.                 break;
  190.             }
  191.         }
  192.         
  193.         if(busta.getTipoOraRegistrazione() != null) {
  194.             switch (busta.getTipoOraRegistrazione()) {
  195.             case LOCALE:
  196.                 busta.setTipoOraRegistrazione(TipoOraRegistrazione.LOCALE,Costanti.TIPO_TEMPO_LOCALE);
  197.                 break;
  198.             case SINCRONIZZATO:
  199.                 busta.setTipoOraRegistrazione(TipoOraRegistrazione.SINCRONIZZATO,Costanti.TIPO_TEMPO_SINCRONIZZATO);
  200.                 break;
  201.             case UNKNOWN:
  202.                 break;
  203.             }
  204.         }
  205.         
  206.         if(busta.getInoltro() != null) {
  207.             switch (busta.getInoltro()) {
  208.             case CON_DUPLICATI:
  209.                 busta.setInoltro(Inoltro.CON_DUPLICATI, Costanti.PROFILO_TRASMISSIONE_CON_DUPLICATI);
  210.                 break;
  211.             case SENZA_DUPLICATI:
  212.                 busta.setInoltro(Inoltro.SENZA_DUPLICATI, Costanti.PROFILO_TRASMISSIONE_SENZA_DUPLICATI);
  213.                 break;
  214.             case UNKNOWN:
  215.                 break;
  216.             }
  217.         }
  218.         
  219.         Iterator<Riscontro> riscontri = busta.getListaRiscontri().iterator();
  220.         while(riscontri.hasNext()){
  221.             Riscontro riscontro = riscontri.next();
  222.             if(riscontro.getTipoOraRegistrazione() == null) 
  223.                 continue;
  224.             if(riscontro.getTipoOraRegistrazione().equals(TipoOraRegistrazione.LOCALE)) 
  225.                 riscontro.setTipoOraRegistrazioneValue(Costanti.TIPO_TEMPO_LOCALE);
  226.             if(riscontro.getTipoOraRegistrazione().equals(TipoOraRegistrazione.SINCRONIZZATO)) 
  227.                 riscontro.setTipoOraRegistrazioneValue(Costanti.TIPO_TEMPO_SINCRONIZZATO);
  228.         }
  229.         
  230.         Iterator<Trasmissione> trasmissioni = busta.getListaTrasmissioni().iterator();
  231.         while(trasmissioni.hasNext()){
  232.             Trasmissione trasmissione = trasmissioni.next();
  233.             if(trasmissione.getTempo() == null) continue;
  234.             
  235.             if(trasmissione.getTempo().equals(TipoOraRegistrazione.LOCALE)) 
  236.                 trasmissione.setTempoValue(Costanti.TIPO_TEMPO_LOCALE);
  237.             else  
  238.                 trasmissione.setTempoValue(Costanti.TIPO_TEMPO_SINCRONIZZATO);
  239.              
  240.         }
  241.         
  242.         ProtocolMessage protocolMessage = new ProtocolMessage();
  243.         protocolMessage.setMessage(msg);
  244.         return protocolMessage;
  245.     }
  246.     
  247.     @Override
  248.     public ProtocolMessage addTrasmissione(OpenSPCoop2Message message,
  249.             Trasmissione trasmissione,
  250.             FaseImbustamento faseImbustamento) throws ProtocolException {
  251.         ProtocolMessage protocolMessage = new ProtocolMessage();
  252.         protocolMessage.setMessage(message);
  253.         return protocolMessage;
  254.     }

  256.     @Override
  257.     public ProtocolMessage sbustamento(OpenSPCoop2Message msg, Context context,
  258.             Busta busta,
  259.             RuoloMessaggio ruoloMessaggio, ProprietaManifestAttachments proprietaManifestAttachments,
  260.             FaseSbustamento faseSbustamento, ServiceBinding integrationServiceBinding, ServiceBindingConfiguration serviceBindingConfiguration) throws ProtocolException {
  261.         
  262.         ProtocolMessage protocolMessage = new ProtocolMessage();
  263.         protocolMessage.setMessage(msg);
  264.         return protocolMessage;
  265.         
  266.     }
  267.     
  268.     
  269.     protected void enrichFault(OpenSPCoop2Message msg, Busta busta, boolean ignoraEccezioniNonGravi,
  270.             boolean modifyFault, boolean generateErroreApplicativoIntoDetail) throws ProtocolException{
  271.         SOAPFault f = null;
  272.         OpenSPCoop2SoapMessage soapMessage = null;
  273.         try{
  274.             if(!modifyFault && !generateErroreApplicativoIntoDetail) {
  275.                 return;
  276.             }
  277.             
  278.             if(ServiceBinding.SOAP.equals(msg.getServiceBinding())){
  279.                 soapMessage = msg.castAsSoap();
  280.                 if(soapMessage.hasSOAPFault()) {
  281.                     if(soapMessage.getSOAPBody()!=null){
  282.                         f = soapMessage.getSOAPBody().getFault();
  283.                     }
  284.                 }
  285.             }
  286.                     
  287.             if(soapMessage==null || f==null){
  288.                 return;
  289.             }
  290.             
  291.             
  292.             // Eccezione
  293.             // NOTA: il parametro 'ignoraEccezioniNonGravi' serve solo a filtrare.
  294.             //       il controllo che esista almeno una eccezione non grave e' fatto dove viene chiamato il metodo.
  295.             Eccezione ecc = null;
  296.             if(busta.sizeListaEccezioni()==1){
  297.                 ecc = busta.getEccezione(0);
  298.             }
  299.             else{
  300.                 ecc = Eccezione.getEccezioneProcessamento(ErroriCooperazione.ERRORE_GENERICO_PROTOCOLLO_NON_CORRETTO.getErroreCooperazione(), this.protocolFactory);
  301.                 StringBuilder bfDescrizione = new StringBuilder();
  302.                 for(int k=0; k<busta.sizeListaEccezioni();k++){
  303.                     Eccezione eccLista = busta.getEccezione(k);
  304.                     if(eccLista.getRilevanza()==null || LivelloRilevanza.isEccezioneLivelloGrave(eccLista.getRilevanza())){
  305.                         if(eccLista.getDescrizione(this.protocolFactory)!=null)
  306.                             bfDescrizione.append("["+this.traduttore.toString(eccLista.getCodiceEccezione(),eccLista.getSubCodiceEccezione())+"] "+eccLista.getDescrizione(this.protocolFactory)+"\n");
  307.                     }
  308.                 }
  309.                 if(bfDescrizione.length()>0)
  310.                     ecc.setDescrizione(bfDescrizione.toString());
  311.             }
  312.             if(ecc==null) {
  313.                 // non ci sono segnalazioni di errore
  314.                 return ;
  315.             }
  316.             
  317.             EccezioneProtocolloBuilderParameters params = new EccezioneProtocolloBuilderParameters();           
  318.             params.setEccezioneProtocollo(ecc);
  319.                         
  320.             if(modifyFault) {
  321.                 // Set Fault Code
  322.                 String codiceEccezione = 
  323.                         this.traduttore.toString(ecc.getCodiceEccezione(),
  324.                                 ecc.getSubCodiceEccezione());
  325.                 QName eccezioneName = this.erroreApplicativoBuilder.getQNameEccezioneProtocollo(null, codiceEccezione);
  326.                 SOAPFaultCode code = params.getSoapFaultCode();
  327.                 soapMessage.setFaultCode(f, code, eccezioneName);
  328.                 
  329.                 // Set fault String
  330.                 soapMessage.setFaultString(f, ecc.getDescrizione(this.protocolFactory));
  331.                 
  332.                 // Set fault Actor
  333.                 f.setFaultActor(org.openspcoop2.utils.Costanti.OPENSPCOOP2);
  334.             }
  335.             
  336.             if(generateErroreApplicativoIntoDetail) {
  337.                 
  338.                 // Soggetto Produce Eccezione == Dominio
  339.                 IDSoggetto soggettoProduceEccezione = new IDSoggetto(busta.getTipoMittente(),busta.getMittente(),busta.getIdentificativoPortaMittente());
  340.                 params.setSoggettoProduceEccezione(soggettoProduceEccezione);
  341.                 params.setDominioPorta(soggettoProduceEccezione);
  342.                 
  343.                 // Mittente (può essere non definito in protocollo che supportano l'invocazione anonima)
  344.                 if(busta.getTipoDestinatario()!=null && busta.getDestinatario()!=null){
  345.                     IDSoggetto idSoggettoMittente = new IDSoggetto(busta.getTipoDestinatario(), busta.getDestinatario());
  346.                     String idPortaMittente = busta.getIdentificativoPortaDestinatario();
  347.                     if(idPortaMittente==null){
  348.                         idPortaMittente = this.traduttore.getIdentificativoPortaDefault(idSoggettoMittente);
  349.                     }
  350.                     idSoggettoMittente.setCodicePorta(idPortaMittente);
  351.                     params.setMittente(idSoggettoMittente);
  352.                 }
  353.                             
  354.                 // Servizio
  355.                 IDServizio idServizio = 
  356.                 IDServizioFactory.getInstance().getIDServizioFromValues(busta.getTipoServizio(), busta.getServizio(), 
  357.                         soggettoProduceEccezione, busta.getVersioneServizio());
  358.                 idServizio.setAzione(busta.getAzione());
  359.                 params.setServizio(idServizio);
  360.                 
  361.                 // MessageType
  362.                 params.setMessageType(msg.getMessageType());
  363.                 
  364.                 // IDFunzione
  365.                 params.setIdFunzione("PortaApplicativa");
  366.                 
  367.                 // ServizioApplicativo
  368.                 params.setServizioApplicativo(busta.getServizioApplicativoErogatore());
  369.                 
  370.                 // TipoPdD
  371.                 params.setTipoPorta(TipoPdD.APPLICATIVA);
  372.                 
  373.                 // genero errore applicativo
  374.                 this.erroreApplicativoBuilder.insertInSOAPFault(params, msg);
  375.             }
  376.             
  377.         }catch(Exception e){
  378.             throw new ProtocolException(e.getMessage(),e);
  379.         }
  380.     }
  381.     
  382. }
Created with JaCoCo 0.8.8.202204050719