TransazioniHelper.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.core.monitor.rs.server.api.impl.utils;


  24. import java.sql.Connection;
  25. import java.util.ArrayList;
  26. import java.util.List;
  27. import java.util.Optional;

  29. import org.apache.commons.lang3.BooleanUtils;
  30. import org.apache.commons.lang3.StringUtils;
  31. import org.openspcoop2.core.id.IDSoggetto;
  32. import org.openspcoop2.core.monitor.rs.server.config.DBManager;
  33. import org.openspcoop2.core.monitor.rs.server.config.LoggerProperties;
  34. import org.openspcoop2.core.monitor.rs.server.config.ServerProperties;
  35. import org.openspcoop2.core.monitor.rs.server.model.EsitoTransazioneFullSearchEnum;
  36. import org.openspcoop2.core.monitor.rs.server.model.FiltroApiBase;
  37. import org.openspcoop2.core.monitor.rs.server.model.FiltroApiSoggetti;
  38. import org.openspcoop2.core.monitor.rs.server.model.FiltroEsito;
  39. import org.openspcoop2.core.monitor.rs.server.model.FiltroMittenteErogazioneApplicativo;
  40. import org.openspcoop2.core.monitor.rs.server.model.FiltroMittenteErogazioneSoggetto;
  41. import org.openspcoop2.core.monitor.rs.server.model.FiltroMittenteFruizioneApplicativo;
  42. import org.openspcoop2.core.monitor.rs.server.model.FiltroMittenteIdAutenticato;
  43. import org.openspcoop2.core.monitor.rs.server.model.FiltroMittenteIndirizzoIP;
  44. import org.openspcoop2.core.monitor.rs.server.model.FiltroMittenteTokenClaim;
  45. import org.openspcoop2.core.monitor.rs.server.model.FiltroMittenteTokenClaimSoggetto;
  46. import org.openspcoop2.core.monitor.rs.server.model.FiltroRicercaRuoloTransazioneEnum;
  47. import org.openspcoop2.core.monitor.rs.server.model.ListaTransazioni;
  48. import org.openspcoop2.core.monitor.rs.server.model.OneOfRicercaIntervalloTemporaleMittente;
  49. import org.openspcoop2.core.monitor.rs.server.model.RicercaBaseTransazione;
  50. import org.openspcoop2.core.monitor.rs.server.model.RicercaIdApplicativo;
  51. import org.openspcoop2.core.monitor.rs.server.model.RicercaIntervalloTemporale;
  52. import org.openspcoop2.generic_project.utils.ServiceManagerProperties;
  53. import org.openspcoop2.message.constants.ServiceBinding;
  54. import org.openspcoop2.monitor.engine.condition.EsitoUtils;
  55. import org.openspcoop2.protocol.sdk.config.IProtocolConfiguration;
  56. import org.openspcoop2.utils.UtilsException;
  57. import org.openspcoop2.utils.service.beans.FiltroRicercaId;
  58. import org.openspcoop2.utils.service.beans.utils.ListaUtils;
  59. import org.openspcoop2.utils.service.fault.jaxrs.FaultCode;
  60. import org.openspcoop2.web.monitor.core.constants.CaseSensitiveMatch;
  61. import org.openspcoop2.web.monitor.core.constants.Costanti;
  62. import org.openspcoop2.web.monitor.core.constants.TipoMatch;
  63. import org.openspcoop2.web.monitor.transazioni.bean.TransazioneBean;
  64. import org.openspcoop2.web.monitor.transazioni.bean.TransazioniSearchForm;
  65. import org.openspcoop2.web.monitor.transazioni.dao.TransazioniService;

  67. /**
  68.  * TransazioniHelper
  69.  * 
  70.  * @author $Author$
  71.  * @version $Rev$, $Date$
  72.  * 
  73.  */
  74. public class TransazioniHelper {
  75.     
  76.     public static boolean isEmpty(IDSoggetto _this) {
  77.         return StringUtils.isEmpty(_this.getTipo()) || StringUtils.isEmpty(_this.getNome()); 
  78.     }

  80.     public static final void overrideFiltroApiBase(FiltroApiBase filtro_api, String azione, IDSoggetto erogatore, TransazioniSearchForm search, MonitoraggioEnv env) {
  81.         
  82.         search.setNomeAzione(azione);
  83.         
  84.         if (filtro_api == null)
  85.             return;
  86.         
  87.         boolean checkAzione = true;
  88.         if(filtro_api instanceof FiltroApiSoggetti) {
  89.             FiltroApiSoggetti f = (FiltroApiSoggetti) filtro_api;
  90.             if(f.getApiImplementata()!=null) {
  91.                 checkAzione = false;
  92.             }
  93.         }
  94.         
  95.         if ( !StringUtils.isEmpty(filtro_api.getNome()) || filtro_api.getVersione() != null || 
  96.                 (checkAzione && !StringUtils.isEmpty(azione)) || 
  97.                 !StringUtils.isEmpty(filtro_api.getTipo())) {
  98.             
  99.             if (StringUtils.isEmpty(filtro_api.getNome())) {
  100.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Filtro Api incompleto. Specificare il nome della API");
  101.             }
  102.                         
  103.             if (erogatore == null || TransazioniHelper.isEmpty(erogatore)) {
  104.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Filtro Api incompleto. Specificare il Soggetto Erogatore (Nelle fruizioni รจ il soggetto remoto)");
  105.             }
  106.             
  107.             if (filtro_api.getVersione() == null) {
  108.                 filtro_api.setVersione(1);
  109.             }
  110.             
  111.             if (filtro_api.getTipo() == null) {
  112.                 try {
  113.                     IProtocolConfiguration protocolConf = env.protocolFactoryMgr
  114.                             .getProtocolFactoryByName(env.tipo_protocollo).createProtocolConfiguration();
  115.                     ServiceBinding defaultBinding = protocolConf.getDefaultServiceBindingConfiguration(null)
  116.                             .getDefaultBinding();
  117.                     filtro_api.setTipo(protocolConf.getTipoServizioDefault(defaultBinding));
  118.                 } catch (Exception e) {
  119.                     throw FaultCode.ERRORE_INTERNO
  120.                             .toException("Impossibile determinare il tipo del servizio: " + e.getMessage());
  121.                 }

  123.             }
  124.             
  125.             String uri = ReportisticaHelper.buildNomeServizioForOverride(filtro_api.getNome(), filtro_api.getTipo(), filtro_api.getVersione(), Optional.of(erogatore));
  126.             if (uri == null) {
  127.                 throw FaultCode.ERRORE_INTERNO.toException("Non sono riuscito a costruire la URI dell'Id Servizio");
  128.             }
  129.             
  130.             search.setNomeServizio(uri);            
  131.         }
  132.     }

  134.     public static final void overrideFiltroFruizione(FiltroApiSoggetti filtro, String azione,
  135.             TransazioniSearchForm search, MonitoraggioEnv env) {
  136.         if (filtro == null)
  137.             return;

  139.         TransazioniHelper.overrideFiltroApiBase(filtro, azione, new IDSoggetto(env.tipoSoggetto, filtro.getErogatore()), search, env);
  140.     }
  141.     
  142.     public static final void overrideFiltroQualsiasi(FiltroApiSoggetti filtro, String azione,
  143.             TransazioniSearchForm search, MonitoraggioEnv env) {
  144.         if (filtro == null)
  145.             return;

  147.         TransazioniHelper.overrideFiltroApiBase(filtro, azione, new IDSoggetto(env.tipoSoggetto, filtro.getErogatore()), search, env);
  148.         if (!StringUtils.isEmpty(filtro.getSoggettoRemoto()))
  149.             search.setTipoNomeTrafficoPerSoggetto(new IDSoggetto(env.tipoSoggetto, filtro.getSoggettoRemoto()).toString()); 
  150.     }
  151.     
  152.     public static final void overrideFiltroRicercaId(FiltroRicercaId filtro, TransazioniSearchForm search,
  153.             MonitoraggioEnv env, String tipoRiconoscimento) {
  154.         if (filtro == null)
  155.             return;

  157.         search.setMittenteMatchingType(
  158.                 (BooleanUtils.isTrue(filtro.isRicercaEsatta()) ? TipoMatch.EQUALS : TipoMatch.LIKE).toString());
  159.         search.setMittenteCaseSensitiveType(
  160.                 (BooleanUtils.isTrue(filtro.isCaseSensitive()) ? CaseSensitiveMatch.SENSITIVE
  161.                         : CaseSensitiveMatch.INSENSITIVE).toString());
  162.         search.setValoreRiconoscimento(filtro.getId());
  163.         search.setRiconoscimento(tipoRiconoscimento);
  164.     }

  166.     public static final void overrideFiltroMittenteIdApplicativo(FiltroMittenteIdAutenticato filtro,
  167.             TransazioniSearchForm search, MonitoraggioEnv env) {
  168.         if (filtro == null)
  169.             return;
  170.         TransazioniHelper.overrideFiltroRicercaId(filtro, search, env, Costanti.VALUE_TIPO_RICONOSCIMENTO_IDENTIFICATIVO_AUTENTICATO);
  171.         search.setAutenticazione(Enums.toTipoAutenticazione.get(filtro.getAutenticazione()).toString());
  172.     }
  173.     
  174.     public static final void overrideFiltroMittenteIndirizzoIP(FiltroMittenteIndirizzoIP filtro,
  175.             TransazioniSearchForm search, MonitoraggioEnv env) {
  176.         if (filtro == null)
  177.             return;
  178.         TransazioniHelper.overrideFiltroRicercaId(filtro, search, env, Costanti.VALUE_TIPO_RICONOSCIMENTO_INDIRIZZO_IP);
  179.         if(filtro.getTipo()!=null) {
  180.             search.setClientAddressMode(Enums.toTipoIndirizzzoIP.get(filtro.getTipo()));
  181.         }
  182.     }

  184.     private static void setEsitoCodice(EsitoTransazioneFullSearchEnum tipo , FiltroEsito filtro, TransazioniSearchForm search) {
  185.         if(filtro.getCodice()!=null) {
  186.             search.setEsitoDettaglio(filtro.getCodice());
  187.         }
  188.         else if(filtro.getCodici()!=null && !filtro.getCodici().isEmpty()) {
  189.             if(filtro.getCodici().size()==1) {
  190.                 search.setEsitoDettaglio(filtro.getCodici().get(0));
  191.             }
  192.             else {
  193.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Con il tipo di esito indicato '"+tipo.toString()+"' puรฒ essere indicato solamente un codice");
  194.             }
  195.         }
  196.     }
  197.     public static final void overrideFiltroEsito(FiltroEsito filtro, TransazioniSearchForm search,
  198.             MonitoraggioEnv env) {
  199.         if (filtro == null)
  200.             return;

  202.         if (filtro != null) {
  203.             
  204.             EsitoTransazioneFullSearchEnum tipo = CheckNotNull.getEsitoTransazione(filtro);
  205.             
  206.             switch (tipo) {
  207.             case QUALSIASI:
  208.                 search.setEsitoGruppo(EsitoUtils.ALL_VALUE);
  209.                 setEsitoCodice(tipo, filtro, search);
  210.                 if(filtro.isEscludiScartate()!=null) {
  211.                     search.setEscludiRichiesteScartate(filtro.isEscludiScartate());
  212.                 }
  213.                 break;
  214.             case OK:
  215.                 search.setEsitoGruppo(EsitoUtils.ALL_OK_VALUE);
  216.                 setEsitoCodice(tipo, filtro, search);
  217.                 break;
  218.             case FAULT:
  219.                 search.setEsitoGruppo(EsitoUtils.ALL_FAULT_APPLICATIVO_VALUE);
  220.                 setEsitoCodice(tipo, filtro, search);
  221.                 break;
  222.             case FALLITE:
  223.                 search.setEsitoGruppo(EsitoUtils.ALL_ERROR_VALUE);
  224.                 setEsitoCodice(tipo, filtro, search);
  225.                 if(filtro.isEscludiScartate()!=null) {
  226.                     search.setEscludiRichiesteScartate(filtro.isEscludiScartate());
  227.                 }
  228.                 break;
  229.             case FALLITE_E_FAULT:
  230.                 search.setEsitoGruppo(EsitoUtils.ALL_ERROR_FAULT_APPLICATIVO_VALUE);
  231.                 setEsitoCodice(tipo, filtro, search);
  232.                 if(filtro.isEscludiScartate()!=null) {
  233.                     search.setEscludiRichiesteScartate(filtro.isEscludiScartate());
  234.                 }
  235.                 break;
  236.             case ERRORI_CONSEGNA:
  237.                 search.setEsitoGruppo(EsitoUtils.ALL_ERROR_CONSEGNA_VALUE);
  238.                 setEsitoCodice(tipo, filtro, search);
  239.                 break;
  240.             case RICHIESTE_SCARTATE:
  241.                 search.setEsitoGruppo(EsitoUtils.ALL_ERROR_RICHIESTE_SCARTATE_VALUE);
  242.                 setEsitoCodice(tipo, filtro, search);
  243.                 break;
  244.             case PERSONALIZZATO:
  245.                 search.setEsitoGruppo(EsitoUtils.ALL_PERSONALIZZATO_VALUE);
  246.                 
  247.                 if(filtro.getCodice()==null && (filtro.getCodici()==null || filtro.getCodici().isEmpty())) {
  248.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException("Con il tipo di esito indicato '"+tipo.toString()+"' deve essere indicato almeno un codice");
  249.                 }
  250.                 List<Integer> dettaglioEsito = filtro.getCodici();
  251.                 if(dettaglioEsito==null || dettaglioEsito.isEmpty()) {
  252.                     dettaglioEsito = new ArrayList<Integer>();
  253.                     dettaglioEsito.add(filtro.getCodice());
  254.                 }
  255.                 search.setEsitoDettaglioPersonalizzato(dettaglioEsito.toArray(new Integer[1]));

  257.                 break;
  258.             }
  259.         }

  261.     }

  263.     public static final void overrideRicercaBaseTransazione(RicercaBaseTransazione body, TransazioniSearchForm search,
  264.             MonitoraggioEnv env) throws Exception {
  265.         if (body == null)
  266.             return;
  267.         
  268.         if (body.getAzione() != null && body.getApi() == null) {
  269.             throw FaultCode.RICHIESTA_NON_VALIDA.toException("Se viene specificato il filtro 'azione' รจ necessario specificare anche il filtro Api");
  270.         }
  271.         
  272.         search.setGruppo(body.getTag());

  274.         if(body.getApi()!=null && body.getApi().getApiImplementata()!=null) {
  275.             search.setApi(ReportisticaHelper.toUriApiImplementata(body.getApi().getApiImplementata(), env));
  276.         }
  277.         
  278.         switch (body.getTipo()) {
  279.         case EROGAZIONE:
  280.             IDSoggetto idSoggettoLocale = new IDSoggetto(env.tipoSoggetto, env.nomeSoggettoLocale);
  281.             TransazioniHelper.overrideFiltroApiBase(body.getApi(), body.getAzione(), idSoggettoLocale, search, env);
  282.             break;
  283.         case FRUIZIONE:
  284.             TransazioniHelper.overrideFiltroFruizione(body.getApi(),body.getAzione(), search, env);
  285.             break;
  286.         case QUALSIASI:
  287.             TransazioniHelper.overrideFiltroQualsiasi(body.getApi(), body.getAzione(), search, env);
  288.             break;
  289.         }

  291.         TransazioniHelper.overrideFiltroEsito(body.getEsito(), search, env);
  292.         search.setEvento(body.getEvento());
  293.         search.setClusterId(body.getIdCluster());
  294.     }
  295.     
  296.     
  297.     public static final void overrideFiltroMittente(RicercaIntervalloTemporale body, TransazioniSearchForm search,
  298.             MonitoraggioEnv env) {
  299.         if (body == null)
  300.             return;

  302.         // Filtraggio Mittente
  303.         
  304.         OneOfRicercaIntervalloTemporaleMittente fMittente = body.getMittente();
  305.         if (fMittente == null)
  306.             return;
  307.         
  308.         final String tipo_soggetto = env.tipoSoggetto;
  309.         switch (body.getTipo()) {
  310.         case FRUIZIONE: {
  311.             
  312.             switch (fMittente.getIdentificazione()) {
  313.             
  314.             case EROGAZIONE_SOGGETTO: {
  315.                 throw FaultCode.RICHIESTA_NON_VALIDA
  316.                     .toException("Identificazione '"+fMittente.getIdentificazione().toString()+"' "
  317.                             + "non utilizzabile in una ricerca di transazioni con il criterio ruolo impostato al valore '"+FiltroRicercaRuoloTransazioneEnum.FRUIZIONE.toString()+"'");
  318.             }
  319.             
  320.             case FRUIZIONE_APPLICATIVO: {
  321.                 
  322.                 if(! (fMittente instanceof FiltroMittenteFruizioneApplicativo)) {
  323.                     throw FaultCode.RICHIESTA_NON_VALIDA
  324.                     .toException("Identificazione '"+fMittente.getIdentificazione().toString()+"' "
  325.                             + "non utilizzabile con il tipo di filtro mittente utilizzato '"+fMittente.getClass().getName()+"' (atteso: "+FiltroMittenteFruizioneApplicativo.class.getName()+")");
  326.                 }
  327.                 FiltroMittenteFruizioneApplicativo fAppl = (FiltroMittenteFruizioneApplicativo) fMittente;
  328.                 search.setRiconoscimento(Costanti.VALUE_TIPO_RICONOSCIMENTO_APPLICATIVO);
  329.                 if(fAppl.getTipoIdentificazioneApplicativo()!=null) {
  330.                     switch (fAppl.getTipoIdentificazioneApplicativo()) {
  331.                     case TRASPORTO:
  332.                         search.setIdentificazione(Costanti.IDENTIFICAZIONE_TRASPORTO_KEY);
  333.                         break;
  334.                     case TOKEN:
  335.                         search.setIdentificazione(Costanti.IDENTIFICAZIONE_TOKEN_KEY);
  336.                         break;
  337.                     }
  338.                 }
  339.                 else {
  340.                     search.setIdentificazione(Costanti.IDENTIFICAZIONE_TRASPORTO_KEY);
  341.                 }
  342.                 search.setServizioApplicativo(fAppl.getApplicativo());
  343.                 
  344.                 search.setTipoNomeMittente(new IDSoggetto(tipo_soggetto, env.nomeSoggettoLocale).toString());
  345.                 
  346.                 break;
  347.             }
  348.             
  349.             case EROGAZIONE_APPLICATIVO: {
  350.                 throw FaultCode.RICHIESTA_NON_VALIDA
  351.                 .toException("Identificazione '"+fMittente.getIdentificazione().toString()+"' "
  352.                         + "non utilizzabile in una ricerca di transazioni con il criterio ruolo impostato al valore '"+FiltroRicercaRuoloTransazioneEnum.FRUIZIONE.toString()+"'");
  353.             }
  354.             
  355.             case IDENTIFICATIVO_AUTENTICATO: {
  356.                 
  357.                 if(! (fMittente instanceof FiltroMittenteIdAutenticato)) {
  358.                     throw FaultCode.RICHIESTA_NON_VALIDA
  359.                     .toException("Identificazione '"+fMittente.getIdentificazione().toString()+"' "
  360.                             + "non utilizzabile con il tipo di filtro mittente utilizzato '"+fMittente.getClass().getName()+"' (atteso: "+FiltroMittenteIdAutenticato.class.getName()+")");
  361.                 }
  362.                 FiltroMittenteIdAutenticato fIdAutenticato = (FiltroMittenteIdAutenticato) fMittente;
  363.                 TransazioniHelper.overrideFiltroMittenteIdApplicativo(fIdAutenticato, search, env);
  364.                 break;
  365.             }

  367.             case EROGAZIONE_TOKEN_INFO: {
  368.                 throw FaultCode.RICHIESTA_NON_VALIDA
  369.                 .toException("Identificazione '"+fMittente.getIdentificazione().toString()+"' "
  370.                         + "non utilizzabile in una ricerca di transazioni con il criterio ruolo impostato al valore '"+FiltroRicercaRuoloTransazioneEnum.FRUIZIONE.toString()+"'");
  371.             }
  372.             
  373.             case TOKEN_INFO: {
  374.                 if(! (fMittente instanceof FiltroMittenteTokenClaim)) {
  375.                     throw FaultCode.RICHIESTA_NON_VALIDA
  376.                     .toException("Identificazione '"+fMittente.getIdentificazione().toString()+"' "
  377.                             + "non utilizzabile con il tipo di filtro mittente utilizzato '"+fMittente.getClass().getName()+"' (atteso: "+FiltroMittenteTokenClaim.class.getName()+")");
  378.                 }
  379.                 FiltroMittenteTokenClaim fClaim = (FiltroMittenteTokenClaim) fMittente;
  380.                 search.setRiconoscimento(Costanti.VALUE_TIPO_RICONOSCIMENTO_TOKEN_INFO);
  381.                 search.setTokenClaim(Enums.toTipoCredenzialeMittente(fClaim.getClaim()).getRawValue());
  382.                 search.setMittenteMatchingType( (BooleanUtils.isTrue(fClaim.isRicercaEsatta()) ? TipoMatch.EQUALS : TipoMatch.LIKE).toString());
  383.                 search.setMittenteCaseSensitiveType( (BooleanUtils.isTrue(fClaim.isCaseSensitive()) ? CaseSensitiveMatch.SENSITIVE : CaseSensitiveMatch.INSENSITIVE).toString());
  384.                 search.setValoreRiconoscimento(fClaim.getId());
  385.                 break;
  386.             }
  387.                 
  388.             case INDIRIZZO_IP: {
  389.                 
  390.                 if(! (fMittente instanceof FiltroMittenteIndirizzoIP)) {
  391.                     throw FaultCode.RICHIESTA_NON_VALIDA
  392.                     .toException("Identificazione '"+fMittente.getIdentificazione().toString()+"' "
  393.                             + "non utilizzabile con il tipo di filtro mittente utilizzato '"+fMittente.getClass().getName()+"' (atteso: "+FiltroMittenteIndirizzoIP.class.getName()+")");
  394.                 }
  395.                 FiltroMittenteIndirizzoIP fIndirizzoIP = (FiltroMittenteIndirizzoIP) fMittente;
  396.                 TransazioniHelper.overrideFiltroMittenteIndirizzoIP(fIndirizzoIP, search, env);
  397.                 break;
  398.             }
  399.                 
  400.             }
  401.             
  402.             break;
  403.         }

  405.         case EROGAZIONE: {
  406.             
  407.             switch (fMittente.getIdentificazione()) {

  409.             case EROGAZIONE_SOGGETTO: {
  410.                 
  411.                 if(! (fMittente instanceof FiltroMittenteErogazioneSoggetto)) {
  412.                     throw FaultCode.RICHIESTA_NON_VALIDA
  413.                     .toException("Identificazione '"+fMittente.getIdentificazione().toString()+"' "
  414.                             + "non utilizzabile con il tipo di filtro mittente utilizzato '"+fMittente.getClass().getName()+"' (atteso: "+FiltroMittenteErogazioneSoggetto.class.getName()+")");
  415.                 }
  416.                 FiltroMittenteErogazioneSoggetto fSogg = (FiltroMittenteErogazioneSoggetto) fMittente;
  417.                 search.setRiconoscimento(Costanti.VALUE_TIPO_RICONOSCIMENTO_SOGGETTO);
  418.                 search.setTipoNomeMittente(new IDSoggetto(tipo_soggetto, fSogg.getSoggetto()).toString());
  419.                 break;
  420.             }
  421.             
  422.             case FRUIZIONE_APPLICATIVO: {
  423.                 throw FaultCode.RICHIESTA_NON_VALIDA
  424.                 .toException("Identificazione '"+fMittente.getIdentificazione().toString()+"' "
  425.                         + "non utilizzabile in una ricerca di transazioni con il criterio ruolo impostato al valore '"+FiltroRicercaRuoloTransazioneEnum.EROGAZIONE.toString()+"'");
  426.             }
  427.             
  428.             case EROGAZIONE_APPLICATIVO: {
  429.                 
  430.                 if(! (fMittente instanceof FiltroMittenteErogazioneApplicativo)) {
  431.                     throw FaultCode.RICHIESTA_NON_VALIDA
  432.                     .toException("Identificazione '"+fMittente.getIdentificazione().toString()+"' "
  433.                             + "non utilizzabile con il tipo di filtro mittente utilizzato '"+fMittente.getClass().getName()+"' (atteso: "+FiltroMittenteErogazioneApplicativo.class.getName()+")");
  434.                 }
  435.                 FiltroMittenteErogazioneApplicativo fAppl = (FiltroMittenteErogazioneApplicativo) fMittente;
  436.                 search.setRiconoscimento(Costanti.VALUE_TIPO_RICONOSCIMENTO_APPLICATIVO);
  437.                 if(fAppl.getTipoIdentificazioneApplicativo()!=null) {
  438.                     switch (fAppl.getTipoIdentificazioneApplicativo()) {
  439.                     case TRASPORTO:
  440.                         search.setIdentificazione(Costanti.IDENTIFICAZIONE_TRASPORTO_KEY);
  441.                         break;
  442.                     case TOKEN:
  443.                         search.setIdentificazione(Costanti.IDENTIFICAZIONE_TOKEN_KEY);
  444.                         break;
  445.                     }
  446.                 }
  447.                 else {
  448.                     search.setIdentificazione(Costanti.IDENTIFICAZIONE_TRASPORTO_KEY);
  449.                 }
  450.                 search.setServizioApplicativo(fAppl.getApplicativo());
  451.                 search.setTipoNomeMittente(new IDSoggetto(tipo_soggetto, fAppl.getSoggetto()).toString());
  452.                 break;
  453.             }
  454.             case IDENTIFICATIVO_AUTENTICATO: {
  455.                 
  456.                 if(! (fMittente instanceof FiltroMittenteIdAutenticato)) {
  457.                     throw FaultCode.RICHIESTA_NON_VALIDA
  458.                     .toException("Identificazione '"+fMittente.getIdentificazione().toString()+"' "
  459.                             + "non utilizzabile con il tipo di filtro mittente utilizzato '"+fMittente.getClass().getName()+"' (atteso: "+FiltroMittenteIdAutenticato.class.getName()+")");
  460.                 }
  461.                 FiltroMittenteIdAutenticato fIdAutenticato = (FiltroMittenteIdAutenticato) fMittente;
  462.                 TransazioniHelper.overrideFiltroMittenteIdApplicativo(fIdAutenticato, search, env);
  463.                 break;
  464.             }

  466.             case EROGAZIONE_TOKEN_INFO: {
  467.                 
  468.                 if(! (fMittente instanceof FiltroMittenteTokenClaimSoggetto)) {
  469.                     throw FaultCode.RICHIESTA_NON_VALIDA
  470.                     .toException("Identificazione '"+fMittente.getIdentificazione().toString()+"' "
  471.                             + "non utilizzabile con il tipo di filtro mittente utilizzato '"+fMittente.getClass().getName()+"' (atteso: "+FiltroMittenteTokenClaimSoggetto.class.getName()+")");
  472.                 }
  473.                 FiltroMittenteTokenClaimSoggetto fClaim = (FiltroMittenteTokenClaimSoggetto) fMittente;
  474.                 search.setRiconoscimento(Costanti.VALUE_TIPO_RICONOSCIMENTO_TOKEN_INFO);
  475.                 search.setTokenClaim(Enums.toTipoCredenzialeMittente(fClaim.getClaim()).getRawValue());
  476.                 search.setMittenteMatchingType( (BooleanUtils.isTrue(fClaim.isRicercaEsatta()) ? TipoMatch.EQUALS : TipoMatch.LIKE).toString());
  477.                 search.setMittenteCaseSensitiveType( (BooleanUtils.isTrue(fClaim.isCaseSensitive()) ? CaseSensitiveMatch.SENSITIVE : CaseSensitiveMatch.INSENSITIVE).toString());
  478.                 search.setValoreRiconoscimento(fClaim.getId());
  479.                 if (!StringUtils.isEmpty(fClaim.getSoggetto()))
  480.                     search.setTipoNomeMittente(new IDSoggetto(tipo_soggetto, fClaim.getSoggetto()).toString());
  481.                 break;
  482.             }
  483.             
  484.             case TOKEN_INFO: {
  485.                 
  486.                 if(! (fMittente instanceof FiltroMittenteTokenClaim)) {
  487.                     throw FaultCode.RICHIESTA_NON_VALIDA
  488.                     .toException("Identificazione '"+fMittente.getIdentificazione().toString()+"' "
  489.                             + "non utilizzabile con il tipo di filtro mittente utilizzato '"+fMittente.getClass().getName()+"' (atteso: "+FiltroMittenteTokenClaim.class.getName()+")");
  490.                 }
  491.                 FiltroMittenteTokenClaim fClaim = (FiltroMittenteTokenClaim) fMittente;
  492.                 search.setRiconoscimento(Costanti.VALUE_TIPO_RICONOSCIMENTO_TOKEN_INFO);
  493.                 search.setTokenClaim(Enums.toTipoCredenzialeMittente(fClaim.getClaim()).getRawValue());
  494.                 search.setMittenteMatchingType( (BooleanUtils.isTrue(fClaim.isRicercaEsatta()) ? TipoMatch.EQUALS : TipoMatch.LIKE).toString());
  495.                 search.setMittenteCaseSensitiveType( (BooleanUtils.isTrue(fClaim.isCaseSensitive()) ? CaseSensitiveMatch.SENSITIVE : CaseSensitiveMatch.INSENSITIVE).toString());
  496.                 search.setValoreRiconoscimento(fClaim.getId());
  497.                 break;
  498.             }
  499.             
  500.             case INDIRIZZO_IP: {

  502.                 if(! (fMittente instanceof FiltroMittenteIndirizzoIP)) {
  503.                     throw FaultCode.RICHIESTA_NON_VALIDA
  504.                     .toException("Identificazione '"+fMittente.getIdentificazione().toString()+"' "
  505.                             + "non utilizzabile con il tipo di filtro mittente utilizzato '"+fMittente.getClass().getName()+"' (atteso: "+FiltroMittenteIndirizzoIP.class.getName()+")");
  506.                 }
  507.                 FiltroMittenteIndirizzoIP fIndirizzoIP = (FiltroMittenteIndirizzoIP) fMittente;
  508.                 TransazioniHelper.overrideFiltroMittenteIndirizzoIP(fIndirizzoIP, search, env);
  509.                 break;
  510.             }
  511.             
  512.             }
  513.             break;
  514.         }
  515.         
  516.         case QUALSIASI: {

  518.             switch (fMittente.getIdentificazione()) {
  519.             
  520.             case EROGAZIONE_SOGGETTO: {
  521.                 throw FaultCode.RICHIESTA_NON_VALIDA
  522.                     .toException("Identificazione '"+fMittente.getIdentificazione().toString()+"' "
  523.                             + "non utilizzabile in una ricerca di transazioni con il criterio ruolo impostato al valore '"+FiltroRicercaRuoloTransazioneEnum.QUALSIASI.toString()+"'");
  524.             }
  525.             
  526.             case FRUIZIONE_APPLICATIVO: {
  527.                 throw FaultCode.RICHIESTA_NON_VALIDA
  528.                 .toException("Identificazione '"+fMittente.getIdentificazione().toString()+"' "
  529.                         + "non utilizzabile in una ricerca di transazioni con il criterio ruolo impostato al valore '"+FiltroRicercaRuoloTransazioneEnum.QUALSIASI.toString()+"'");
  530.             }
  531.             
  532.             case EROGAZIONE_APPLICATIVO: {
  533.                 throw FaultCode.RICHIESTA_NON_VALIDA
  534.                 .toException("Identificazione '"+fMittente.getIdentificazione().toString()+"' "
  535.                         + "non utilizzabile in una ricerca di transazioni con il criterio ruolo impostato al valore '"+FiltroRicercaRuoloTransazioneEnum.QUALSIASI.toString()+"'");
  536.             }
  537.             
  538.             case IDENTIFICATIVO_AUTENTICATO: {
  539.                 
  540.                 if(! (fMittente instanceof FiltroMittenteIdAutenticato)) {
  541.                     throw FaultCode.RICHIESTA_NON_VALIDA
  542.                     .toException("Identificazione '"+fMittente.getIdentificazione().toString()+"' "
  543.                             + "non utilizzabile con il tipo di filtro mittente utilizzato '"+fMittente.getClass().getName()+"' (atteso: "+FiltroMittenteIdAutenticato.class.getName()+")");
  544.                 }
  545.                 FiltroMittenteIdAutenticato fIdAutenticato = (FiltroMittenteIdAutenticato) fMittente;
  546.                 TransazioniHelper.overrideFiltroMittenteIdApplicativo(fIdAutenticato, search, env);
  547.                 break;
  548.             }

  550.             case EROGAZIONE_TOKEN_INFO: {
  551.                 throw FaultCode.RICHIESTA_NON_VALIDA
  552.                 .toException("Identificazione '"+fMittente.getIdentificazione().toString()+"' "
  553.                         + "non utilizzabile in una ricerca di transazioni con il criterio ruolo impostato al valore '"+FiltroRicercaRuoloTransazioneEnum.QUALSIASI.toString()+"'");
  554.             }
  555.             
  556.             case TOKEN_INFO: {
  557.                 
  558.                 if(! (fMittente instanceof FiltroMittenteTokenClaim)) {
  559.                     throw FaultCode.RICHIESTA_NON_VALIDA
  560.                     .toException("Identificazione '"+fMittente.getIdentificazione().toString()+"' "
  561.                             + "non utilizzabile con il tipo di filtro mittente utilizzato '"+fMittente.getClass().getName()+"' (atteso: "+FiltroMittenteTokenClaim.class.getName()+")");
  562.                 }
  563.                 FiltroMittenteTokenClaim fClaim = (FiltroMittenteTokenClaim) fMittente;
  564.                 search.setRiconoscimento(Costanti.VALUE_TIPO_RICONOSCIMENTO_TOKEN_INFO);
  565.                 search.setTokenClaim(Enums.toTipoCredenzialeMittente(fClaim.getClaim()).getRawValue());
  566.                 search.setMittenteMatchingType( (BooleanUtils.isTrue(fClaim.isRicercaEsatta()) ? TipoMatch.EQUALS : TipoMatch.LIKE).toString());
  567.                 search.setMittenteCaseSensitiveType( (BooleanUtils.isTrue(fClaim.isCaseSensitive()) ? CaseSensitiveMatch.SENSITIVE : CaseSensitiveMatch.INSENSITIVE).toString());
  568.                 search.setValoreRiconoscimento(fClaim.getId());
  569.                 break;
  570.             }
  571.             
  572.             case INDIRIZZO_IP: {
  573.                 
  574.                 if(! (fMittente instanceof FiltroMittenteIndirizzoIP)) {
  575.                     throw FaultCode.RICHIESTA_NON_VALIDA
  576.                     .toException("Identificazione '"+fMittente.getIdentificazione().toString()+"' "
  577.                             + "non utilizzabile con il tipo di filtro mittente utilizzato '"+fMittente.getClass().getName()+"' (atteso: "+FiltroMittenteIndirizzoIP.class.getName()+")");
  578.                 }
  579.                 FiltroMittenteIndirizzoIP fIndirizzoIP = (FiltroMittenteIndirizzoIP) fMittente;
  580.                 TransazioniHelper.overrideFiltroMittenteIndirizzoIP(fIndirizzoIP, search, env);
  581.                 break;
  582.             }
  583.             
  584.             }
  585.             break;
  586.         }
  587.         
  588.         }
  589.     }

  591.     /**
  592.      * Effettua la ricerca delle transazioni dato un oggetto TransazioniSearchForm correttamente popolato
  593.      */
  594.     public static final ListaTransazioni searchTransazioni(TransazioniSearchForm search, Integer offset, Integer limit,
  595.             String sort, MonitoraggioEnv env) throws UtilsException, InstantiationException, IllegalAccessException {
  596.         DBManager dbManager = DBManager.getInstance();
  597.         Connection connection = null;
  598.         try {
  599.             connection = dbManager.getConnectionTracce();
  600.             ServerProperties serverProperties = ServerProperties.getInstance();
  601.             ServiceManagerProperties smp = dbManager.getServiceManagerPropertiesTracce();
  602.             TransazioniService transazioniService = new TransazioniService(connection, true, smp,
  603.                     LoggerProperties.getLoggerDAO());
  604.             transazioniService.setSearch(search);

  606.             List<TransazioneBean> listTransazioniDB = transazioniService.findAll(Converter.toOffset(offset),
  607.                     Converter.toLimit(limit), Converter.toSortOrder(sort), Converter.toSortField(sort));
  608.             if(listTransazioniDB!=null && !listTransazioniDB.isEmpty()) {
  609.                 for (TransazioneBean transazioneBean : listTransazioniDB) {
  610.                     if(transazioneBean.getGruppiRawValue()!=null && !"".equals(transazioneBean.getGruppiRawValue())) {
  611.                         try {
  612.                             transazioniService.normalizeInfoTransazioniFromCredenzialiMittenteGruppi(transazioneBean, transazioneBean);
  613.                         }catch(Exception e) {
  614.                             throw new UtilsException(e.getMessage(),e);
  615.                         }
  616.                     }
  617.                     
  618.                     // finisce in principal
  619.                     if(transazioneBean.getTrasportoMittenteLabel()==null) {
  620.                         if(transazioneBean.getTrasportoMittente()!=null && !"".equals(transazioneBean.getTrasportoMittente())) {
  621.                             try {
  622.                                 transazioniService.normalizeInfoTransazioniFromCredenzialiMittenteTrasporto(transazioneBean, transazioneBean);
  623.                             }catch(Exception e) {
  624.                                 throw new UtilsException(e.getMessage(),e);
  625.                             }
  626.                         }
  627.                     }
  628.                     
  629.                     // finisce in utente
  630.                     if(transazioneBean.getTokenUsernameLabel()==null) {
  631.                         if(transazioneBean.getTokenUsername()!=null && !"".equals(transazioneBean.getTokenUsername())) {
  632.                             try {
  633.                                 transazioniService.normalizeInfoTransazioniFromCredenzialiMittenteTokenUsername(transazioneBean, transazioneBean);
  634.                             }catch(Exception e) {
  635.                                 throw new UtilsException(e.getMessage(),e);
  636.                             }
  637.                         }
  638.                     }
  639.                     
  640.                     // finisce in client
  641.                     if(transazioneBean.getTokenClientIdLabel()==null) {
  642.                         if(transazioneBean.getTokenClientId()!=null && !"".equals(transazioneBean.getTokenClientId())) {
  643.                             try {
  644.                                 transazioniService.normalizeInfoTransazioniFromCredenzialiMittenteTokenClientID(transazioneBean, transazioneBean);
  645.                             }catch(Exception e) {
  646.                                 throw new UtilsException(e.getMessage(),e);
  647.                             }
  648.                         }
  649.                     }
  650.                     
  651.                     // finisce in indirizzoClient e indirizzoClientInoltrato
  652.                     if(transazioneBean.getTransportClientAddressLabel()==null && transazioneBean.getSocketClientAddressLabel()==null) {
  653.                         if(transazioneBean.getClientAddress()!=null && !"".equals(transazioneBean.getClientAddress())) {
  654.                             try {
  655.                                 transazioniService.normalizeInfoTransazioniFromCredenzialiMittenteClientAddress(transazioneBean, transazioneBean);
  656.                             }catch(Exception e) {
  657.                                 throw new UtilsException(e.getMessage(),e);
  658.                             }
  659.                         }
  660.                     }
  661.                 }
  662.             }
  663.             
  664.             ListaTransazioni ret = ListaUtils.costruisciLista(env.context.getUriInfo(),
  665.                     Converter.toOffset(offset), Converter.toLimit(limit),
  666.                     listTransazioniDB != null ? listTransazioniDB.size() : 0, ListaTransazioni.class);

  668.             if (serverProperties.isFindall404() && (listTransazioniDB == null || listTransazioniDB.isEmpty()))
  669.                 throw FaultCode.NOT_FOUND
  670.                         .toException("Nessuna transazione trovata corrispondente ai criteri di ricerca");

  672.             if (listTransazioniDB != null && !listTransazioniDB.isEmpty()) {
  673.                 listTransazioniDB.forEach(transazioneDB -> {
  674.                     try {
  675.                         ret.addItemsItem(Converter.toItemTransazione(transazioneDB, env.log));
  676.                     } catch (Exception e) {
  677.                         throw new RuntimeException(e.getMessage(), e);
  678.                     }
  679.                 });
  680.             }

  682.             env.context.getLogger().info("Invocazione completata con successo");
  683.             return ret;
  684.         } finally {
  685.             dbManager.releaseConnectionTracce(connection);
  686.         }
  687.     }
  688.     
  689.     
  690.     public static final ListaTransazioni findAllTransazioniByIdApplicativo(RicercaIdApplicativo body, MonitoraggioEnv env) throws Exception {
  691.         SearchFormUtilities searchFormUtilities = new SearchFormUtilities();
  692.         TransazioniSearchForm search = searchFormUtilities.getIdApplicativoSearchForm(env.context, env.profilo, env.nomeSoggettoLocale, 
  693.                 body.getTipo(), body.getIntervalloTemporale().getDataInizio(), body.getIntervalloTemporale().getDataFine());
  694.         
  695.         TransazioniHelper.overrideRicercaBaseTransazione(body, search, env);

  697.         FiltroRicercaId filtro = body.getIdApplicativo();
  698.         search.setCorrelazioneApplicativaCaseSensitiveType((BooleanUtils.isTrue(filtro.isCaseSensitive()) ? CaseSensitiveMatch.SENSITIVE : CaseSensitiveMatch.INSENSITIVE).toString() );
  699.         search.setCorrelazioneApplicativaMatchingType((BooleanUtils.isTrue(filtro.isRicercaEsatta()) ? TipoMatch.EQUALS : TipoMatch.LIKE).toString());
  700.         search.setIdCorrelazioneApplicativa(filtro.getId());            
  701.         
  702.         ListaTransazioni ret = TransazioniHelper.searchTransazioni(search, body.getOffset(), body.getLimit(), body.getSort(), env);
  703.         return ret;
  704.     }
  705.     
  706.     
  707.     public static final ListaTransazioni findAllTransazioni(RicercaIntervalloTemporale body, MonitoraggioEnv env) throws Exception {
  708.         SearchFormUtilities searchFormUtilities = new SearchFormUtilities();
  709.         TransazioniSearchForm search = searchFormUtilities.getAndamentoTemporaleSearchForm(env.context, env.profilo, env.nomeSoggettoLocale, 
  710.                 body.getTipo(), body.getIntervalloTemporale().getDataInizio(), body.getIntervalloTemporale().getDataFine());
  711.         
  712.         TransazioniHelper.overrideRicercaBaseTransazione(body, search, env);
  713.         TransazioniHelper.overrideFiltroMittente(body, search, env);
  714.         
  715.         return TransazioniHelper.searchTransazioni(search, body.getOffset(), body.getLimit(), body.getSort(), env); 
  716.     }
  717. }
Created with JaCoCo 0.8.8.202204050719