IdentificazionePortaApplicativa.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.PortaApplicativa;
  30. import org.openspcoop2.core.config.constants.PortaApplicativaAzioneIdentificazione;
  31. import org.openspcoop2.core.config.constants.StatoFunzionalita;
  32. import org.openspcoop2.core.id.IDPortaApplicativa;
  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.ProtocolFiltroRicercaPorteApplicative;
  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 applicativa richiesta.
  51.  *
  52.  * @author Andrea Poli (apoli@link.it)
  53.  * @author $Author$
  54.  * @version $Rev$, $Date$
  55.  */

  57. public class IdentificazionePortaApplicativa extends AbstractIdentificazionePorta {


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

  110.     @Override
  111.     protected Object getIDPorta(String porta) throws RegistryNotFound, RegistryException{
  112.         return this.configIntegrationReader.getIdPortaApplicativa(porta, this.protocolFactory);
  113.     }

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

  133.         try{

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

  160.             return true;

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

  174.     public IDPortaApplicativa getIDPortaApplicativa(){
  175.         return (IDPortaApplicativa) this.identificativoPorta;
  176.     }

  178.     public PortaApplicativa getPortaApplicativa() {
  179.         return this.pa;
  180.     } 

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

  265.     public PortaApplicativa getPortaApplicativa(String action) {
  266.         if(this.paDelegatedByAction.containsKey(action)) {
  267.             return this.paDelegatedByAction.get(action);
  268.         }
  269.         return null;
  270.     } 
  271. }
Created with JaCoCo 0.8.8.202204050719