IdentificazionePortaDelegata.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.basic.registry;

  25. import java.util.ArrayList;
  26. import java.util.HashMap;
  27. import java.util.List;

  29. import org.openspcoop2.core.config.PortaDelegata;
  30. import org.openspcoop2.core.config.constants.PortaDelegataAzioneIdentificazione;
  31. import org.openspcoop2.core.config.constants.StatoFunzionalita;
  32. import org.openspcoop2.core.id.IDPortaDelegata;
  33. import org.openspcoop2.protocol.registry.RegistroServiziManager;
  34. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  35. import org.openspcoop2.protocol.sdk.ProtocolException;
  36. import org.openspcoop2.protocol.sdk.constants.CodiceErroreIntegrazione;
  37. import org.openspcoop2.protocol.sdk.constants.ErroriIntegrazione;
  38. import org.openspcoop2.protocol.sdk.registry.ProtocolFiltroRicercaPorteDelegate;
  39. import org.openspcoop2.protocol.sdk.registry.IConfigIntegrationReader;
  40. import org.openspcoop2.protocol.sdk.registry.IRegistryReader;
  41. import org.openspcoop2.protocol.sdk.registry.RegistryException;
  42. import org.openspcoop2.protocol.sdk.registry.RegistryNotFound;
  43. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  44. import org.openspcoop2.utils.BooleanNullable;
  45. import org.openspcoop2.utils.transport.TransportRequestContext;
  46. import org.slf4j.Logger;


  49. /**
  50.  * Classe utilizzabile per identificare la porta delegata richiesta.
  51.  *
  52.  * @author Andrea Poli (apoli@link.it)
  53.  * @author $Author$
  54.  * @version $Rev$, $Date$
  55.  */

  57. public class IdentificazionePortaDelegata extends AbstractIdentificazionePorta {



  61.     /* ---- Porta Delegata ---- */
  62.     private PortaDelegata pd = null;
  63.     
  64.     /* ---- Porta Delegata (Azione specifica) ---- */
  65.     private HashMap<String, PortaDelegata> pdDelegatedByAction = new HashMap<String, PortaDelegata>();
  66.     private HashMap<String, IDPortaDelegata> idPdDelegatedByAction = new HashMap<String, IDPortaDelegata>();
  67.     
  68.     
  69.     /**
  70.      * Costruttore
  71.      *
  72.      * @param urlProtocolContext Parametri identificativi della porta delegata.
  73.      * @throws ProtocolException 
  74.      * 
  75.      */
  76.     public IdentificazionePortaDelegata(TransportRequestContext urlProtocolContext, Logger log,
  77.             boolean portaUrlBased, IRegistryReader registryReader, IConfigIntegrationReader configIntegrationReader,
  78.             IProtocolFactory<?> protocolFactory) throws ProtocolException {
  79.         super(urlProtocolContext, log, portaUrlBased, registryReader, configIntegrationReader, protocolFactory);
  80.     }
  81.     /*public IdentificazionePortaDelegata(Logger log, IProtocolFactory<?> protocolFactory, org.openspcoop2.protocol.sdk.state.IState state,
  82.             PortaDelegata pd)
  83.             throws ProtocolException {
  84.         super(log, protocolFactory, state);
  85.         this.pd = pd;
  86.         IDPortaDelegata idPD = new IDPortaDelegata();
  87.         idPD.setNome(this.pd.getNome());
  88.         this.identificativoPorta = idPD;
  89.     }*/
  90.     public IdentificazionePortaDelegata(Logger log, IProtocolFactory<?> protocolFactory, 
  91.             RegistroServiziManager registroServiziManager, Object configurazioneManager, RequestInfo requestInfo,
  92.             PortaDelegata pd)
  93.             throws ProtocolException {
  94.         super(log, protocolFactory, registroServiziManager, configurazioneManager, requestInfo);
  95.         this.pd = pd;
  96.         IDPortaDelegata idPD = new IDPortaDelegata();
  97.         idPD.setNome(this.pd.getNome());
  98.         this.identificativoPorta = idPD;
  99.     }
  100.     public IdentificazionePortaDelegata(Logger log, IProtocolFactory<?> protocolFactory, 
  101.             IRegistryReader registryReader, IConfigIntegrationReader configIntegrationReader, RequestInfo requestInfo,
  102.             PortaDelegata pd)
  103.             throws ProtocolException {
  104.         super(log, protocolFactory, registryReader, configIntegrationReader, requestInfo);
  105.         this.pd = pd;
  106.         IDPortaDelegata idPD = new IDPortaDelegata();
  107.         idPD.setNome(this.pd.getNome());
  108.         this.identificativoPorta = idPD;
  109.     }


  112.     @Override
  113.     protected Object getIDPorta(String porta) throws RegistryNotFound, RegistryException{
  114.         return this.configIntegrationReader.getIdPortaDelegata(porta, this.protocolFactory);
  115.     }
  116.     
  117.     @Override
  118.     protected String enrichPorta(String porta) throws RegistryException{
  119.         try {
  120.             return this.porteNamingUtils.enrichPD(porta);
  121.         }catch(Exception e) {
  122.             throw new RegistryException(e.getMessage(),e);
  123.         }
  124.     }
  125.     
  126.     /**
  127.      * Avvia il processo di identificazione.
  128.      *
  129.      * @return true in caso di identificazione con successo, false altrimenti.
  130.      * 
  131.      */
  132.     @Override
  133.     public boolean process() {

  135.         try{

  137.             if(super.process()==false){
  138.                 return false;
  139.             }
  140.             
  141.             IDPortaDelegata idPD = this.getIDPortaDelegata();
  142.             
  143.             // Get Porta Delegata
  144.             try{
  145.                 this.pd = this.configIntegrationReader.getPortaDelegata(idPD);
  146.             }catch(RegistryNotFound notFound){
  147.                 this.erroreIntegrazione = 
  148.                         ErroriIntegrazione.ERRORE_401_PORTA_INESISTENTE.
  149.                             getErrore401_PortaInesistente(notFound.getMessage(),idPD.getNome(),this.urlCompleta);
  150.                 return false;
  151.             }
  152.             
  153.             // Verifico che l'azione non sia in modalità delegatedBy
  154.             if(this.pd.getAzione()!=null && PortaDelegataAzioneIdentificazione.DELEGATED_BY.equals(this.pd.getAzione().getIdentificazione())) {
  155.                 this.erroreIntegrazione = 
  156.                         ErroriIntegrazione.ERRORE_441_PORTA_NON_INVOCABILE_DIRETTAMENTE.
  157.                             getErrore441_PortaNonInvocabileDirettamente(idPD.getNome(),this.urlCompleta);
  158.                 return false;
  159.             }

  161.             return true;

  163.         }catch(Exception e){
  164.             this.log.error("Identificazione porta delegata non riuscita location["+this.location+"] urlInvocazione["+this.urlCompleta+"]",e);
  165.             try{
  166.                 this.erroreIntegrazione = ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  167.                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_502_IDENTIFICAZIONE_PORTA);
  168.             }catch(Exception eError){
  169.                 throw new RuntimeException(eError.getMessage(), eError);
  170.             }
  171.             return false;
  172.         }
  173.     }

  175.     public IDPortaDelegata getIDPortaDelegata(){
  176.         return (IDPortaDelegata) this.identificativoPorta;
  177.     }

  179.     public PortaDelegata getPortaDelegata() {
  180.         return this.pd;
  181.     } 

  183.     /**
  184.      * Avvia il processo di identificazione della porta per l'azione specifica.
  185.      *
  186.      * @return true in caso di identificazione con successo, false altrimenti.
  187.      * 
  188.      */
  189.     public boolean find(String action) {
  190.         try {
  191.             
  192.             if(this.pd.getRicercaPortaAzioneDelegata()!=null && StatoFunzionalita.ABILITATO.equals(this.pd.getRicercaPortaAzioneDelegata())) {
  193.                 
  194.                 ProtocolFiltroRicercaPorteDelegate filtroPD = new ProtocolFiltroRicercaPorteDelegate();
  195.                 filtroPD.setNomePortaDelegante(getIDPortaDelegata().getNome());
  196.                 filtroPD.setAzione(action);
  197.                 List<IDPortaDelegata> list = null;
  198.                 IDPortaDelegata idPD = null;
  199.                 boolean useRequestInfo = false;
  200.                 boolean addRequestInfo = false;
  201.                 try {
  202.                     useRequestInfo = this.requestInfo!=null && this.requestInfo.getRequestConfig()!=null;
  203.                     if(useRequestInfo) {
  204.                         BooleanNullable nullConditionsList = BooleanNullable.NULL();
  205.                         list = this.requestInfo.getRequestConfig().getPorteDelegateByFiltroRicerca(filtroPD, nullConditionsList);
  206.                         if(nullConditionsList==null || nullConditionsList.getValue()==null) {
  207.                             list = null;
  208.                         }
  209.                     }
  210.                     
  211.                     if(list==null) {
  212.                         addRequestInfo = true;
  213.                         list = this.configIntegrationReader.findIdPorteDelegate(filtroPD);
  214.                     }
  215.                                         
  216.                 }catch(RegistryNotFound notFound) {
  217.                     list=new ArrayList<>();
  218.                 }
  219.                 
  220.                 if(useRequestInfo && addRequestInfo) {
  221.                     this.requestInfo.getRequestConfig().addPorteDelegateByFiltroRicerca(filtroPD, list, 
  222.                             this.requestInfo.getIdTransazione());
  223.                 }
  224.                 
  225.                 if(list!=null && list.size()>0) {
  226.                     if(list.size()>1) {
  227.                         throw new Exception("Trovate più porte ("+list.size()+") che corrisponde al filtro?? ("+filtroPD+")");
  228.                     }
  229.                     idPD = list.get(0);
  230.                     this.idPdDelegatedByAction.put(action, idPD);
  231.                     
  232.                     try{
  233.                         PortaDelegata pd = this.configIntegrationReader.getPortaDelegata(idPD);
  234.                         this.pdDelegatedByAction.put(action, pd);
  235.                     }catch(RegistryNotFound notFound){
  236.                         this.erroreIntegrazione = 
  237.                                 ErroriIntegrazione.ERRORE_401_PORTA_INESISTENTE.
  238.                                     getErrore401_PortaInesistente(notFound.getMessage(),idPD.getNome(),this.urlCompleta);
  239.                         return false;
  240.                     }
  241.                 }
  242.                 
  243.             }
  244.             
  245.             return true;
  246.             
  247.         }catch(Exception e){
  248.             this.log.error("Identificazione porta delegata non riuscita per azione specifica ["+action+"], porta delegata di base["+getIDPortaDelegata().getNome()+"]",e);
  249.             try{
  250.                 this.erroreIntegrazione = ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  251.                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_502_IDENTIFICAZIONE_PORTA);
  252.             }catch(Exception eError){
  253.                 throw new RuntimeException(eError.getMessage(), eError);
  254.             }
  255.             return false;
  256.         }
  257.     }
  258.     
  259.     public IDPortaDelegata getIDPortaDelegata(String action){
  260.         if(this.idPdDelegatedByAction.containsKey(action)) {
  261.             return this.idPdDelegatedByAction.get(action);
  262.         }
  263.         return null;
  264.     }

  266.     public PortaDelegata getPortaDelegata(String action) {
  267.         if(this.pdDelegatedByAction.containsKey(action)) {
  268.             return this.pdDelegatedByAction.get(action);
  269.         }
  270.         return null;
  271.     } 
  272. }
Created with JaCoCo 0.8.8.202204050719