ConnettoreMsg.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.pdd.core.connettori;

  25. import java.util.Date;
  26. import java.util.Iterator;
  27. import java.util.List;
  28. import java.util.Map;

  30. import org.openspcoop2.core.config.InvocazioneCredenziali;
  31. import org.openspcoop2.core.config.Property;
  32. import org.openspcoop2.core.config.driver.DriverConfigurazioneException;
  33. import org.openspcoop2.core.config.driver.DriverConfigurazioneNotFound;
  34. import org.openspcoop2.core.constants.CostantiConnettori;
  35. import org.openspcoop2.core.id.IDAccordo;
  36. import org.openspcoop2.core.id.IDPortaApplicativa;
  37. import org.openspcoop2.core.transazioni.TransazioneApplicativoServer;
  38. import org.openspcoop2.message.OpenSPCoop2Message;
  39. import org.openspcoop2.pdd.config.ConfigurazionePdDManager;
  40. import org.openspcoop2.pdd.config.ForwardProxy;
  41. import org.openspcoop2.pdd.core.PdDContext;
  42. import org.openspcoop2.pdd.core.controllo_traffico.PolicyTimeoutConfig;
  43. import org.openspcoop2.pdd.core.handlers.OutRequestContext;
  44. import org.openspcoop2.pdd.core.token.PolicyNegoziazioneToken;
  45. import org.openspcoop2.pdd.logger.MsgDiagnostico;
  46. import org.openspcoop2.protocol.sdk.Busta;
  47. import org.openspcoop2.protocol.sdk.BustaRawContent;
  48. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  49. import org.openspcoop2.protocol.sdk.ProtocolException;
  50. import org.openspcoop2.protocol.sdk.ProtocolMessage;
  51. import org.openspcoop2.protocol.sdk.builder.ProprietaManifestAttachments;
  52. import org.openspcoop2.protocol.sdk.constants.FaseSbustamento;
  53. import org.openspcoop2.protocol.sdk.constants.RuoloMessaggio;
  54. import org.openspcoop2.protocol.sdk.state.IState;
  55. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  56. import org.openspcoop2.utils.transport.TransportRequestContext;

  58. /**
  59.  * Classe utilizzata per rappresentare le informazioni utilizzata da un generico connettore.
  60.  *
  61.  * @author Poli Andrea (apoli@link.it)
  62.  * @author $Author$
  63.  * @version $Rev$, $Date$
  64.  */

  66. public class ConnettoreMsg  {


  69.     /* ********  F I E L D S  P R I V A T I  ******** */

  71.     /** Tipo di Connettore */
  72.     private String tipoConnector;
  73.     /** Messaggio da spedire */
  74.     private OpenSPCoop2Message request;
  75.     /** Proprieta' del connettore */
  76.     private java.util.Map<String,String> properties;
  77.     /** Errore generato con un prefisso del connettore */
  78.     protected boolean generateErrorWithConnectorPrefix = true;

  80.     /** Indicazione su di un eventuale sbustamento SOAP */
  81.     private boolean sbustamentoSoap;
  82.     /** Indicazione su di un eventuale sbustamento delle informazioni di protocollo */
  83.     private boolean sbustamentoInformazioniProtocollo; 
  84.     /** Proprieta' di trasporto che deve utilizzare il connettore */
  85.     private Map<String, List<String>> propertiesTrasporto;
  86.     /** Proprieta' urlBased che deve utilizzare il connettore */
  87.     private Map<String, List<String>> propertiesUrlBased;
  88.     /** Tipo di Autenticazione */
  89.     private String tipoAutenticazione;
  90.     /** Credenziali per l'autenticazione */
  91.     private InvocazioneCredenziali credenziali;
  92.     /** Busta */
  93.     private Busta busta;
  94.     /** Identificativo Modulo che utilizza il connettore */
  95.     private String idModulo;
  96.     /** ProtocolFactory */
  97.     private IProtocolFactory<?> protocolFactory;
  98.     /** Attributi per lo sbustamento del protocollo */
  99.     private boolean gestioneManifest = false;
  100.     private ProprietaManifestAttachments proprietaManifestAttachments = null;
  101.     /** Eventuale header sbustato contenente le informazioni di protocollo */
  102.     private BustaRawContent<?> soapProtocolInfo = null;
  103.     /** Informazione sulla modalita LocalForward */
  104.     private boolean localForward = false;
  105.     /** Indicazione se il messaggio in consegna riguarda una richiesta o una risposta
  106.      * Il set di questo field, potrà essere usato per la risposta di una invocazione sincrona con consegna su I.M. */
  107.     private RuoloMessaggio ruoloMessaggio = RuoloMessaggio.RICHIESTA;
  108.     /** Policy Token */
  109.     private PolicyNegoziazioneToken policyNegoziazioneToken;
  110.     private PolicyTimeoutConfig policyTimeoutConfig;
  111.     
  112.     /** OutRequestContext */
  113.     private OutRequestContext outRequestContext;
  114.     /** MessaggioDiagnostico */
  115.     private MsgDiagnostico msgDiagnostico;
  116.     /** IState */
  117.     private IState state;
  118.     
  119.     private TransazioneApplicativoServer transazioneApplicativoServer;
  120.     private IDPortaApplicativa idPortaApplicativa;
  121.     private Date dataConsegnaTransazioneApplicativoServer;
  122.     
  123.     private ForwardProxy forwardProxy;
  124.     
  125.     private IDAccordo idAccordo;
  126.     
  127.     private String urlInvocazionePorta;
  128.     
  129.     private Boolean forceSendContent = null;




  134.     /* ********  C O S T R U T T O R E  ******** */
  135.     /**
  136.      * Costruttore. 
  137.      *
  138.      * 
  139.      */
  140.     public ConnettoreMsg(){}
  141.     /**
  142.      * Costruttore. 
  143.      *
  144.      * @param type Tipo di Connettore
  145.      * @param r Messaggio di Richiesta
  146.      * @param p Proprieta' del Connettore
  147.      * 
  148.      */
  149.     public ConnettoreMsg(String type,OpenSPCoop2Message r,
  150.             Property[] p){
  151.         java.util.Map<String,String> pr = new java.util.HashMap<>();
  152.         if(p!=null){
  153.             for(int i=0; i<p.length; i++){
  154.                 if(p[i]!=null){
  155.                     pr.put(p[i].getNome(),p[i].getValore());
  156.                 }
  157.             }
  158.         }
  159.         this.tipoConnector = type;
  160.         this.request = r;
  161.         this.properties = pr;
  162.     }
  163.     /**
  164.      * Costruttore. 
  165.      *
  166.      * @param type Tipo di Connettore
  167.      * @param r Messaggio di Richiesta
  168.      * @param p Proprieta' del Connettore
  169.      * 
  170.      */
  171.     public ConnettoreMsg(String type,OpenSPCoop2Message r,
  172.             java.util.Map<String,String> p){
  173.         this(type,r,p,false,null,null,true);
  174.     }
  175.     /**
  176.      * Costruttore. 
  177.      *
  178.      * @param type Tipo di Connettore
  179.      * @param r Messaggio di Richiesta
  180.      * @param p Proprieta' del Connettore
  181.      * @param sb Indicazione su di un eventuale sbustamento SOAP
  182.      * @param tipoAuth Tipo di Autenticazione associata al connettore
  183.      * @param cr Credenziali Associate al connettore
  184.      * 
  185.      */
  186.     public ConnettoreMsg(String type,OpenSPCoop2Message r,
  187.             Property[] p,boolean sb,
  188.             String tipoAuth,InvocazioneCredenziali cr,
  189.             boolean isRichiesta){
  190.         this(type,r,new java.util.HashMap<>() ,sb,tipoAuth,cr,isRichiesta);

  192.         java.util.Map<String,String> pr = new java.util.HashMap<>();
  193.         if(p!=null){
  194.             for(int i=0; i<p.length; i++){
  195.                 if(p[i]!=null){
  196.                     pr.put(p[i].getNome(),p[i].getValore());
  197.                 }
  198.             }
  199.         }
  200.         this.properties = pr;
  201.     }
  202.     /**
  203.      * Costruttore. 
  204.      *
  205.      * @param type Tipo di Connettore
  206.      * @param r Messaggio di Richiesta
  207.      * @param p Proprieta' del Connettore
  208.      * @param sb Indicazione su di un eventuale sbustamento SOAP
  209.      * @param tipoAuth Tipo di Autenticazione associata al connettore
  210.      * @param cr Credenziali Associate al connettore
  211.      * 
  212.      */
  213.     public ConnettoreMsg(String type,OpenSPCoop2Message r,
  214.             java.util.Map<String,String> p,boolean sb,
  215.             String tipoAuth,InvocazioneCredenziali cr,
  216.             boolean isRichiesta){

  218.         this.tipoConnector = type;
  219.         this.request = r;
  220.         this.properties = p;
  221.         this.sbustamentoSoap = sb;
  222.         this.tipoAutenticazione = tipoAuth;
  223.         this.credenziali = cr;
  224.     }



  228.     

  230.     /* ********  S E T T E R   ******** */
  231.     
  232.     /**
  233.      * Imposta il tipo di connettore.
  234.      *
  235.      * @param tipo Tipo di Connettore.
  236.      * 
  237.      */    
  238.     public void setTipoConnettore(String tipo) {
  239.         this.tipoConnector = tipo;
  240.     }
  241.     /**
  242.      * Imposta il messaggio da spedire.
  243.      *
  244.      * @param r Messaggio da Spedire
  245.      * 
  246.      */   
  247.     public void setRequestMessage(OpenSPCoop2Message r) {
  248.         this.request = r;
  249.     }
  250.     /**
  251.      * Imposta le proprieta' del connettore.
  252.      *
  253.      * @param p Proprieta' del Connettore
  254.      * 
  255.      */   
  256.     public void setConnectorProperties(java.util.Map<String,String> p) {
  257.         this.properties = p;
  258.     }
  259.     /**
  260.      * Imposta l'indicazione su di un eventuale sbustamento SOAP.
  261.      *
  262.      * @param sb indicazione su di un eventuale sbustamento SOAP.
  263.      * 
  264.      */    
  265.     public void setSbustamentoSOAP(boolean sb) {
  266.         this.sbustamentoSoap = sb;
  267.     }
  268.     
  269.     /**
  270.      * Imposta il tipo di autenticazione associato al connettore
  271.      *
  272.      * @param tipoAuth tipo di autenticazione.
  273.      * 
  274.      */
  275.     public void setAutenticazione(String tipoAuth){
  276.         this.tipoAutenticazione = tipoAuth;
  277.     }
  278.     /**
  279.      * Imposta le credenziali associate all'autenticazione utilizzata dal connettore
  280.      *
  281.      * @param cr Credenziali
  282.      * 
  283.      */
  284.     public void setCredenziali(InvocazioneCredenziali cr){
  285.         this.credenziali = cr;
  286.     }
  287.     
  288.     public void setGenerateErrorWithConnectorPrefix(boolean generateErrorWithConnectorPrefix) {
  289.         this.generateErrorWithConnectorPrefix = generateErrorWithConnectorPrefix;
  290.     }
  291.     
  292.     public void setIdAccordo(IDAccordo id) {
  293.         this.idAccordo = id;
  294.     }
  295.     
  296.     public void setUrlInvocazionePorta(String urlInvocazionePorta) {
  297.         this.urlInvocazionePorta = urlInvocazionePorta;
  298.     }
  299.     
  300.     public void forceSendContent() {
  301.         this.forceSendContent = true;
  302.     }


  305.     /* ********  G E T T E R   ******** */

  307.     /**
  308.      * Ritorna il tipo di connettore.
  309.      *
  310.      * @return Tipo di Connettore.
  311.      * 
  312.      */    
  313.     public String getTipoConnettore() {
  314.         return this.tipoConnector;
  315.     }
  316.     /**
  317.      * Ritorna il messaggio da spedire.
  318.      *
  319.      * @return Messaggio da Spedire
  320.      * 
  321.      */  
  322.     private boolean sbustamentoProtocolInfoEffettuato = false;
  323.     private boolean checkPresenzaHeaderPrimaSbustamento = false;
  324.     public void setCheckPresenzaHeaderPrimaSbustamento(boolean checkPresenzaHeaderPrimaSbustamento) {
  325.         this.checkPresenzaHeaderPrimaSbustamento = checkPresenzaHeaderPrimaSbustamento;
  326.     }
  327.     public OpenSPCoop2Message getRequestMessage(RequestInfo requestInfo, PdDContext pddContext) throws ProtocolException {
  328.         if(!this.localForward && this.sbustamentoInformazioniProtocollo && !this.sbustamentoProtocolInfoEffettuato){
  329.             boolean protocolloPresente = true;
  330.             if(this.checkPresenzaHeaderPrimaSbustamento){
  331.                 try{
  332.                     protocolloPresente = this.protocolFactory.createValidazioneSintattica(this.state).
  333.                         verifyProtocolPresence(this.outRequestContext.getTipoPorta(), this.busta.getProfiloDiCollaborazione(), this.ruoloMessaggio, this.request);
  334.                 }catch(Exception e){}
  335.             }
  336.             if(protocolloPresente){
  337.                 org.openspcoop2.protocol.engine.builder.Sbustamento sbustatore = 
  338.                         new org.openspcoop2.protocol.engine.builder.Sbustamento(this.protocolFactory,this.state);
  339.                     ProtocolMessage protocolMessage = sbustatore.sbustamento(this.request,pddContext,
  340.                             this.busta,
  341.                             this.ruoloMessaggio,this.gestioneManifest,this.proprietaManifestAttachments,
  342.                             FaseSbustamento.PRE_CONSEGNA_RICHIESTA, requestInfo);
  343.                     if(protocolMessage!=null) {
  344.                         this.soapProtocolInfo = protocolMessage.getBustaRawContent();
  345.                         this.request = protocolMessage.getMessage(); // updated
  346.                     }
  347.                     this.sbustamentoProtocolInfoEffettuato = true;
  348.             }
  349.         }
  350.         return this.request;
  351.     }
  352.     public TransportRequestContext getTransportRequestContext() {
  353.         if(this.request!=null) {
  354.             return this.request.getTransportRequestContext();
  355.         }
  356.         return null;
  357.     }
  358.     
  359.     /**
  360.      * Ritorna le proprieta' del connettore.
  361.      *
  362.      * @return Proprieta' del Connettore
  363.      * 
  364.      */   
  365.     public java.util.Map<String,String> getConnectorProperties() {
  366.         return this.properties;
  367.     }
  368.     /**
  369.      * Ritorna l'indicazione su di un eventuale sbustamento SOAP.
  370.      *
  371.      * @return indicazione su di un eventuale sbustamento SOAP.
  372.      * 
  373.      */    
  374.     public boolean isSbustamentoSOAP() {
  375.         return this.sbustamentoSoap;
  376.     }
  377.     
  378.     /**
  379.      * Ritorna il tipo di autenticazione associato al connettore
  380.      *
  381.      * @return tipo di autenticazione.
  382.      * 
  383.      */
  384.     public String getAutenticazione(){
  385.         return this.tipoAutenticazione;
  386.     }
  387.     /**
  388.      * Ritorna le credenziali associate all'autenticazione utilizzata dal connettore
  389.      *
  390.      * @return Credenziali
  391.      * 
  392.      */
  393.     public InvocazioneCredenziali getCredenziali(){
  394.         return this.credenziali;
  395.     }
  396.     /**
  397.      * @return the propertiesTrasporto
  398.      */
  399.     public Map<String, List<String>> getPropertiesTrasporto() {
  400.         return this.propertiesTrasporto;
  401.     }
  402.     /**
  403.      * @return the propertiesUrlBased
  404.      */
  405.     public Map<String, List<String>> getPropertiesUrlBased() {
  406.         return this.propertiesUrlBased;
  407.     }
  408.     /**
  409.      * @param propertiesTrasporto the propertiesTrasporto to set
  410.      */
  411.     public void setPropertiesTrasporto(Map<String, List<String>> propertiesTrasporto) {
  412.         this.propertiesTrasporto = propertiesTrasporto;
  413.     }
  414.     /**
  415.      * @param propertiesUrlBased the propertiesUrlBased to set
  416.      */
  417.     public void setPropertiesUrlBased(Map<String, List<String>> propertiesUrlBased) {
  418.         this.propertiesUrlBased = propertiesUrlBased;
  419.     }
  420.     /**
  421.      * @return the busta
  422.      */
  423.     public Busta getBusta() {
  424.         return this.busta;
  425.     }
  426.     /**
  427.      * @param busta the busta to set
  428.      */
  429.     public void setBusta(Busta busta) {
  430.         this.busta = busta;
  431.     }

  433.     public String getIdModulo() {
  434.         return this.idModulo;
  435.     }
  436.     public void setIdModulo(String idModulo) {
  437.         this.idModulo = idModulo;
  438.     }
  439.     
  440.     public boolean isSbustamentoInformazioniProtocollo() {
  441.         return this.sbustamentoInformazioniProtocollo;
  442.     }
  443.     public void setSbustamentoInformazioniProtocollo(
  444.             boolean sbustamentoInformazioniProtocollo) {
  445.         this.sbustamentoInformazioniProtocollo = sbustamentoInformazioniProtocollo;
  446.     }
  447.     public RuoloMessaggio getRuoloMessaggio() {
  448.         return this.ruoloMessaggio;
  449.     }
  450.     public void setRuoloMessaggio(RuoloMessaggio ruoloMessaggio) {
  451.         this.ruoloMessaggio = ruoloMessaggio;
  452.     }
  453.     public void setProtocolFactory(IProtocolFactory<?> protocolFactory) {
  454.         this.protocolFactory = protocolFactory;
  455.     }
  456.     
  457.     public void setGestioneManifest(boolean gestioneManifest) {
  458.         this.gestioneManifest = gestioneManifest;
  459.     }
  460.     public void setProprietaManifestAttachments(
  461.             ProprietaManifestAttachments proprietaManifestAttachments) {
  462.         this.proprietaManifestAttachments = proprietaManifestAttachments;
  463.     }
  464.     public BustaRawContent<?> getSoapProtocolInfo() {
  465.         return this.soapProtocolInfo;
  466.     }
  467.     public boolean isLocalForward() {
  468.         return this.localForward;
  469.     }
  470.     public void setLocalForward(boolean localForward) {
  471.         this.localForward = localForward;
  472.     }
  473.     public OutRequestContext getOutRequestContext() {
  474.         return this.outRequestContext;
  475.     }
  476.     public void setOutRequestContext(OutRequestContext outRequestContext) {
  477.         this.outRequestContext = outRequestContext;
  478.     }
  479.     public MsgDiagnostico getMsgDiagnostico() {
  480.         return this.msgDiagnostico;
  481.     }
  482.     public void setMsgDiagnostico(MsgDiagnostico msgDiagnostico) {
  483.         this.msgDiagnostico = msgDiagnostico;
  484.     }
  485.     public IState getState() {
  486.         return this.state;
  487.     }
  488.     public void setState(IState state) {
  489.         this.state = state;
  490.     }
  491.     public boolean isGenerateErrorWithConnectorPrefix() {
  492.         return this.generateErrorWithConnectorPrefix;
  493.     }

  495.     public PolicyNegoziazioneToken getPolicyNegoziazioneToken() {
  496.         return this.policyNegoziazioneToken;
  497.     }
  498.     public void setPolicyNegoziazioneToken(PolicyNegoziazioneToken policyNegoziazioneToken) {
  499.         this.policyNegoziazioneToken = policyNegoziazioneToken;
  500.     }
  501.     public void initPolicyGestioneToken(ConfigurazionePdDManager configPdDManager, RequestInfo requestInfo) throws DriverConfigurazioneException, DriverConfigurazioneNotFound {
  502.         if(this.properties!=null && !this.properties.isEmpty()) {
  503.             Iterator<String> en = this.properties.keySet().iterator();
  504.             while (en.hasNext()) {
  505.                 String propertyName = en.next();
  506.                 if(CostantiConnettori.CONNETTORE_TOKEN_POLICY.equals(propertyName)) {
  507.                     String tokenPolicy = this.properties.get(propertyName);
  508.                     if(tokenPolicy!=null && !"".equals(tokenPolicy)) {
  509.                         boolean forceNoCache = true;
  510.                         this.policyNegoziazioneToken = configPdDManager.getPolicyNegoziazioneToken(!forceNoCache, tokenPolicy, requestInfo);
  511.                     }
  512.                 }
  513.             }
  514.         }
  515.     }
  516.     
  517.     public PolicyTimeoutConfig getPolicyTimeoutConfig() {
  518.         return this.policyTimeoutConfig;
  519.     }
  520.     public void setPolicyTimeoutConfig(PolicyTimeoutConfig policyConfig) {
  521.         this.policyTimeoutConfig = policyConfig;
  522.     }
  523.     
  524.     public TransazioneApplicativoServer getTransazioneApplicativoServer() {
  525.         return this.transazioneApplicativoServer;
  526.     }
  527.     public void setTransazioneApplicativoServer(TransazioneApplicativoServer transazioneApplicativoServer) {
  528.         this.transazioneApplicativoServer = transazioneApplicativoServer;
  529.     }
  530.     public IDPortaApplicativa getIdPortaApplicativa() {
  531.         return this.idPortaApplicativa;
  532.     }
  533.     public void setIdPortaApplicativa(IDPortaApplicativa idPortaApplicativa) {
  534.         this.idPortaApplicativa = idPortaApplicativa;
  535.     }
  536.     public Date getDataConsegnaTransazioneApplicativoServer() {
  537.         return this.dataConsegnaTransazioneApplicativoServer;
  538.     }
  539.     public void setDataConsegnaTransazioneApplicativoServer(Date dataConsegnaTransazioneApplicativoServer) {
  540.         this.dataConsegnaTransazioneApplicativoServer = dataConsegnaTransazioneApplicativoServer;
  541.     }
  542.     
  543.     public ForwardProxy getForwardProxy() {
  544.         return this.forwardProxy;
  545.     }
  546.     public void setForwardProxy(ForwardProxy forwardProxy) {
  547.         this.forwardProxy = forwardProxy;
  548.     }
  549.     
  550.     public IDAccordo getIdAccordo() {
  551.         return this.idAccordo;
  552.     }
  553.     
  554.     public String getUrlInvocazionePorta() {
  555.         return this.urlInvocazionePorta;
  556.     }
  557.     
  558.     public boolean isForceSendContent() {
  559.         return this.forceSendContent!=null ? this.forceSendContent.booleanValue() : false;
  560.     }
  561. }
Created with JaCoCo 0.8.8.202204050719