Enums.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.  */

  20. package org.openspcoop2.core.monitor.rs.server.api.impl.utils;

  21. import java.util.EnumMap;
  22. import java.util.HashMap;
  23. import java.util.Map;

  24. import org.openspcoop2.core.config.constants.TipoAutenticazione;

  25. import org.openspcoop2.core.eventi.constants.TipoSeverita;
  26. import org.openspcoop2.core.monitor.rs.server.model.DimensioniReportCustomEnum;
  27. import org.openspcoop2.core.monitor.rs.server.model.DimensioniReportEnum;
  28. import org.openspcoop2.core.monitor.rs.server.model.EsitoTransazioneFullSearchEnum;
  29. import org.openspcoop2.core.monitor.rs.server.model.FiltroRicercaRuoloTransazioneEnum;
  30. import org.openspcoop2.core.monitor.rs.server.model.FormatoReportEnum;
  31. import org.openspcoop2.core.monitor.rs.server.model.OccupazioneBandaEnum;
  32. import org.openspcoop2.core.monitor.rs.server.model.TempoMedioRispostaEnum;
  33. import org.openspcoop2.core.monitor.rs.server.model.TipoFiltroMittenteEnum;
  34. import org.openspcoop2.core.monitor.rs.server.model.TipoFiltroMittenteIdentificativoAutenticatoEnum;
  35. import org.openspcoop2.core.monitor.rs.server.model.TipoFiltroMittenteIndirizzoIPEnum;
  36. import org.openspcoop2.core.monitor.rs.server.model.TipoInformazioneReportEnum;
  37. import org.openspcoop2.core.monitor.rs.server.model.TipoReportEnum;
  38. import org.openspcoop2.core.monitor.rs.server.model.TokenClaimDistribuzioneStatisticaEnum;
  39. import org.openspcoop2.core.monitor.rs.server.model.TokenClaimEnum;
  40. import org.openspcoop2.core.monitor.rs.server.model.TokenClaimSearchEnum;
  41. import org.openspcoop2.core.monitor.rs.server.model.UnitaTempoReportEnum;
  42. import org.openspcoop2.core.statistiche.constants.TipoBanda;
  43. import org.openspcoop2.core.statistiche.constants.TipoLatenza;
  44. import org.openspcoop2.core.statistiche.constants.TipoVisualizzazione;
  45. import org.openspcoop2.core.transazioni.utils.TipoCredenzialeMittente;
  46. import org.openspcoop2.monitor.engine.condition.EsitoUtils;
  47. import org.openspcoop2.monitor.sdk.constants.StatisticType;
  48. import org.openspcoop2.utils.service.beans.DiagnosticoSeveritaEnum;
  49. import org.openspcoop2.utils.service.beans.TransazioneRuoloEnum;
  50. import org.openspcoop2.web.monitor.statistiche.bean.DimensioneCustom;
  51. import org.openspcoop2.web.monitor.statistiche.bean.NumeroDimensioni;
  52. import org.openspcoop2.web.monitor.statistiche.constants.CostantiExporter;

  53. /**
  54.  * Enums
  55.  *
  56.  * @author $Author$
  57.  * @version $Rev$, $Date$
  58.  *
  59.  */
  60. public class Enums {

  61.     public static final <T1, T2> Map<T1, T2> dualizeMap(Map<T2, T1> map) {
  62.         HashMap<T1, T2> ret = new HashMap<T1, T2>();

  63.         map.forEach((t2, t1) -> ret.put(t1, t2));

  64.         return ret;
  65.     }

  66.     public static final Map<DiagnosticoSeveritaEnum, TipoSeverita> toTipoSeverita = new HashMap<>();
  67.     static {
  68.         Enums.toTipoSeverita.put(DiagnosticoSeveritaEnum.DEBUG, TipoSeverita.DEBUG);
  69.         Enums.toTipoSeverita.put(DiagnosticoSeveritaEnum.ERROR, TipoSeverita.ERROR);
  70.         Enums.toTipoSeverita.put(DiagnosticoSeveritaEnum.FATAL, TipoSeverita.FATAL);
  71.         Enums.toTipoSeverita.put(DiagnosticoSeveritaEnum.INFO, TipoSeverita.INFO);
  72.         Enums.toTipoSeverita.put(DiagnosticoSeveritaEnum.WARNING, TipoSeverita.WARN);
  73.     }
  74.     public static final Map<TipoSeverita, DiagnosticoSeveritaEnum> toDiagnosticoSeverita = Enums
  75.             .dualizeMap(Enums.toTipoSeverita);

  76.     public static final Map<EsitoTransazioneFullSearchEnum, Integer> toEsitoGruppo = new HashMap<>();
  77.     static {
  78.         Enums.toEsitoGruppo.put(EsitoTransazioneFullSearchEnum.QUALSIASI, EsitoUtils.ALL_VALUE);
  79.         Enums.toEsitoGruppo.put(EsitoTransazioneFullSearchEnum.OK, EsitoUtils.ALL_OK_VALUE);
  80.         Enums.toEsitoGruppo.put(EsitoTransazioneFullSearchEnum.FAULT, EsitoUtils.ALL_FAULT_APPLICATIVO_VALUE);
  81.         Enums.toEsitoGruppo.put(EsitoTransazioneFullSearchEnum.FALLITE, EsitoUtils.ALL_ERROR_VALUE);
  82.         Enums.toEsitoGruppo.put(EsitoTransazioneFullSearchEnum.FALLITE_E_FAULT, EsitoUtils.ALL_ERROR_FAULT_APPLICATIVO_VALUE);
  83.         Enums.toEsitoGruppo.put(EsitoTransazioneFullSearchEnum.ERRORI_CONSEGNA, EsitoUtils.ALL_ERROR_CONSEGNA_VALUE);
  84.         Enums.toEsitoGruppo.put(EsitoTransazioneFullSearchEnum.RICHIESTE_SCARTATE, EsitoUtils.ALL_ERROR_RICHIESTE_SCARTATE_VALUE);
  85.         Enums.toEsitoGruppo.put(EsitoTransazioneFullSearchEnum.PERSONALIZZATO, EsitoUtils.ALL_PERSONALIZZATO_VALUE);
  86.     }

  87.     public static final Map<TipoFiltroMittenteIdentificativoAutenticatoEnum, TipoAutenticazione> toTipoAutenticazione = new HashMap<>();
  88.     static {
  89.         Enums.toTipoAutenticazione.put(TipoFiltroMittenteIdentificativoAutenticatoEnum.BASIC, TipoAutenticazione.BASIC);
  90.         Enums.toTipoAutenticazione.put(TipoFiltroMittenteIdentificativoAutenticatoEnum.PRINCIPAL, TipoAutenticazione.PRINCIPAL);
  91.         Enums.toTipoAutenticazione.put(TipoFiltroMittenteIdentificativoAutenticatoEnum.SSL, TipoAutenticazione.SSL);
  92.     }
  93.    
  94.     public static final Map<TipoFiltroMittenteIndirizzoIPEnum, String> toTipoIndirizzzoIP = new HashMap<>();
  95.     static {
  96.         Enums.toTipoIndirizzzoIP.put(TipoFiltroMittenteIndirizzoIPEnum.CLIENT_IP, org.openspcoop2.web.monitor.core.constants.Costanti.VALUE_CLIENT_ADDRESS_SOCKET);
  97.         Enums.toTipoIndirizzzoIP.put(TipoFiltroMittenteIndirizzoIPEnum.X_FORWARDED_FOR, org.openspcoop2.web.monitor.core.constants.Costanti.VALUE_CLIENT_ADDRESS_TRASPORTO);
  98.     }

  99.     public static final Map<TokenClaimEnum, String> toTokenClaim = new HashMap<>();
  100.     static {
  101.         Enums.toTokenClaim.put(TokenClaimEnum.CLIENT_ID, CostantiExporter.CLAIM_CLIENT_ID);
  102.         Enums.toTokenClaim.put(TokenClaimEnum.EMAIL, CostantiExporter.CLAIM_EMAIL);
  103.         Enums.toTokenClaim.put(TokenClaimEnum.ISSUER, CostantiExporter.CLAIM_ISSUER);
  104.         Enums.toTokenClaim.put(TokenClaimEnum.SUBJECT, CostantiExporter.CLAIM_SUBJECT);
  105.         Enums.toTokenClaim.put(TokenClaimEnum.USERNAME, CostantiExporter.CLAIM_USERNAME);
  106.     }
  107.    
  108.     public static final Map<TokenClaimSearchEnum, String> toTokenSearchClaim = new HashMap<>();
  109.     static {
  110.         Enums.toTokenSearchClaim.put(TokenClaimSearchEnum.CLIENT_ID, CostantiExporter.CLAIM_CLIENT_ID);
  111.         Enums.toTokenSearchClaim.put(TokenClaimSearchEnum.EMAIL, CostantiExporter.CLAIM_EMAIL);
  112.         Enums.toTokenSearchClaim.put(TokenClaimSearchEnum.ISSUER, CostantiExporter.CLAIM_ISSUER);
  113.         Enums.toTokenSearchClaim.put(TokenClaimSearchEnum.SUBJECT, CostantiExporter.CLAIM_SUBJECT);
  114.         Enums.toTokenSearchClaim.put(TokenClaimSearchEnum.USERNAME, CostantiExporter.CLAIM_USERNAME);
  115.         Enums.toTokenSearchClaim.put(TokenClaimSearchEnum.PDND_ORGANIZATION_NAME, CostantiExporter.CLAIM_PDND_ORGANIZATION_NAME);
  116.     }

  117.     public static final Map<FormatoReportEnum, String> toTipoFormato = new HashMap<>();
  118.     static {
  119.         Enums.toTipoFormato.put(FormatoReportEnum.CSV, CostantiExporter.TIPO_FORMATO_CSV);
  120.         Enums.toTipoFormato.put(FormatoReportEnum.JSON, CostantiExporter.TIPO_FORMATO_JSON);
  121.         Enums.toTipoFormato.put(FormatoReportEnum.PDF, CostantiExporter.TIPO_FORMATO_PDF);
  122.         // toTipoFormato.put(FormatoReportEnum.PNG, CostantiExporter.TIPO_FORMATO_PNG);
  123.         Enums.toTipoFormato.put(FormatoReportEnum.XLS, CostantiExporter.TIPO_FORMATO_XLS);
  124.         Enums.toTipoFormato.put(FormatoReportEnum.XML, CostantiExporter.TIPO_FORMATO_XML);

  125.     }

  126.     public static final Map<TipoReportEnum, org.openspcoop2.core.statistiche.constants.TipoReport> toTipoReport = new HashMap<>();
  127.     static {
  128.         Enums.toTipoReport.put(TipoReportEnum.BAR, org.openspcoop2.core.statistiche.constants.TipoReport.BAR_CHART);
  129.         Enums.toTipoReport.put(TipoReportEnum.LINE, org.openspcoop2.core.statistiche.constants.TipoReport.LINE_CHART);
  130.         Enums.toTipoReport.put(TipoReportEnum.PIE, org.openspcoop2.core.statistiche.constants.TipoReport.PIE_CHART);
  131.         Enums.toTipoReport.put(TipoReportEnum.TABLE, org.openspcoop2.core.statistiche.constants.TipoReport.TABELLA);
  132.     }

  133.     public static final Map<TipoInformazioneReportEnum, TipoVisualizzazione> toTipoVisualizzazione = new HashMap<>();
  134.     static {
  135.         Enums.toTipoVisualizzazione.put(TipoInformazioneReportEnum.NUMERO_TRANSAZIONI,
  136.                 TipoVisualizzazione.NUMERO_TRANSAZIONI);
  137.         Enums.toTipoVisualizzazione.put(TipoInformazioneReportEnum.OCCUPAZIONE_BANDA,
  138.                 TipoVisualizzazione.DIMENSIONE_TRANSAZIONI);
  139.         Enums.toTipoVisualizzazione.put(TipoInformazioneReportEnum.TEMPO_MEDIO_RISPOSTA,
  140.                 TipoVisualizzazione.TEMPO_MEDIO_RISPOSTA);
  141.     }
  142.    
  143.     private static final EnumMap<DimensioniReportEnum, NumeroDimensioni> toNumeroDimensioni = new EnumMap<>(DimensioniReportEnum.class);
  144.     public static Map<DimensioniReportEnum, NumeroDimensioni> getNumeroDimensioniMap() {
  145.         return toNumeroDimensioni;
  146.     }
  147.     static {
  148.         Enums.toNumeroDimensioni.put(DimensioniReportEnum._2D,
  149.                 NumeroDimensioni.DIMENSIONI_2);
  150.         Enums.toNumeroDimensioni.put(DimensioniReportEnum._3D,
  151.                 NumeroDimensioni.DIMENSIONI_3);
  152.         Enums.toNumeroDimensioni.put(DimensioniReportEnum._3DCUSTOM,
  153.                 NumeroDimensioni.DIMENSIONI_3_CUSTOM);
  154.     }
  155.    
  156.     private static final EnumMap<DimensioniReportCustomEnum, DimensioneCustom> toInformazioneDimensioneCustom = new EnumMap<>(DimensioniReportCustomEnum.class);
  157.     public static Map<DimensioniReportCustomEnum, DimensioneCustom> getInformazioneDimensioneCustom() {
  158.         return toInformazioneDimensioneCustom;
  159.     }
  160.     static {
  161.         Enums.toInformazioneDimensioneCustom.put(DimensioniReportCustomEnum.TAG,
  162.                 DimensioneCustom.TAG);
  163.         Enums.toInformazioneDimensioneCustom.put(DimensioniReportCustomEnum.API,
  164.                 DimensioneCustom.API);
  165.         Enums.toInformazioneDimensioneCustom.put(DimensioniReportCustomEnum.API_IMPLEMENTATION,
  166.                 DimensioneCustom.IMPLEMENTAZIONE_API);
  167.         Enums.toInformazioneDimensioneCustom.put(DimensioniReportCustomEnum.OPERATION,
  168.                 DimensioneCustom.OPERAZIONE);
  169.         Enums.toInformazioneDimensioneCustom.put(DimensioniReportCustomEnum.LOCAL_ORGANIZATION,
  170.                 DimensioneCustom.SOGGETTO_LOCALE);
  171.         Enums.toInformazioneDimensioneCustom.put(DimensioniReportCustomEnum.REMOTE_ORGANIZATION,
  172.                 DimensioneCustom.SOGGETTO_REMOTO);
  173.         Enums.toInformazioneDimensioneCustom.put(DimensioniReportCustomEnum.CLIENT_ORGANIZATION,
  174.                 DimensioneCustom.SOGGETTO_FRUITORE);
  175.         Enums.toInformazioneDimensioneCustom.put(DimensioniReportCustomEnum.PROVIDER_ORGANIZATION,
  176.                 DimensioneCustom.SOGGETTO_EROGATORE);
  177.         Enums.toInformazioneDimensioneCustom.put(DimensioniReportCustomEnum.TOKEN_ISSUER,
  178.                 DimensioneCustom.TOKEN_ISSUER);
  179.         Enums.toInformazioneDimensioneCustom.put(DimensioniReportCustomEnum.TOKEN_CLIENTID,
  180.                 DimensioneCustom.TOKEN_CLIENT_ID);
  181.         Enums.toInformazioneDimensioneCustom.put(DimensioniReportCustomEnum.TOKEN_SUBJECT,
  182.                 DimensioneCustom.TOKEN_SUBJECT);
  183.         Enums.toInformazioneDimensioneCustom.put(DimensioniReportCustomEnum.TOKEN_USERNAME,
  184.                 DimensioneCustom.TOKEN_USERNAME);
  185.         Enums.toInformazioneDimensioneCustom.put(DimensioniReportCustomEnum.TOKEN_EMAIL,
  186.                 DimensioneCustom.TOKEN_EMAIL);
  187.         Enums.toInformazioneDimensioneCustom.put(DimensioniReportCustomEnum.TOKEN_PDND_ORGANIZATION,
  188.                 DimensioneCustom.TOKEN_PDND_ORGANIZATION);
  189.         Enums.toInformazioneDimensioneCustom.put(DimensioniReportCustomEnum.PRINCIPAL,
  190.                 DimensioneCustom.PRINCIPAL);
  191.         Enums.toInformazioneDimensioneCustom.put(DimensioniReportCustomEnum.CLIENT,
  192.                 DimensioneCustom.APPLICATIVO_TRASPORTO);
  193.         Enums.toInformazioneDimensioneCustom.put(DimensioniReportCustomEnum.TOKEN_CLIENT,
  194.                 DimensioneCustom.APPLICATIVO_TOKEN);
  195.         Enums.toInformazioneDimensioneCustom.put(DimensioniReportCustomEnum.IP_ADDRESS,
  196.                 DimensioneCustom.INDIRIZZO_IP);
  197.         Enums.toInformazioneDimensioneCustom.put(DimensioniReportCustomEnum.RESULT,
  198.                 DimensioneCustom.ESITO);
  199.     }

  200.     public static final Map<OccupazioneBandaEnum, TipoBanda> toTipoBanda = new HashMap<>();
  201.     static {
  202.         Enums.toTipoBanda.put(OccupazioneBandaEnum.COMPLESSIVA, TipoBanda.COMPLESSIVA);
  203.         Enums.toTipoBanda.put(OccupazioneBandaEnum.ESTERNA, TipoBanda.ESTERNA);
  204.         Enums.toTipoBanda.put(OccupazioneBandaEnum.INTERNA, TipoBanda.INTERNA);
  205.     }

  206.     public static final Map<TempoMedioRispostaEnum, TipoLatenza> toTipoLatenza = new HashMap<>();
  207.     static {
  208.         Enums.toTipoLatenza.put(TempoMedioRispostaEnum.GATEWAY, TipoLatenza.LATENZA_PORTA);
  209.         Enums.toTipoLatenza.put(TempoMedioRispostaEnum.SERVIZIO, TipoLatenza.LATENZA_SERVIZIO);
  210.         Enums.toTipoLatenza.put(TempoMedioRispostaEnum.TOTALE, TipoLatenza.LATENZA_TOTALE);
  211.     }

  212.     public static final Map<TokenClaimEnum, String> toClaim = new HashMap<>();
  213.     static {
  214.         Enums.toClaim.put(TokenClaimEnum.CLIENT_ID, CostantiExporter.CLAIM_CLIENT_ID);
  215.         Enums.toClaim.put(TokenClaimEnum.EMAIL, CostantiExporter.CLAIM_EMAIL);
  216.         Enums.toClaim.put(TokenClaimEnum.ISSUER, CostantiExporter.CLAIM_ISSUER);
  217.         Enums.toClaim.put(TokenClaimEnum.SUBJECT, CostantiExporter.CLAIM_SUBJECT);
  218.         Enums.toClaim.put(TokenClaimEnum.USERNAME, CostantiExporter.CLAIM_USERNAME);
  219.     }
  220.    
  221.     public static final Map<TokenClaimDistribuzioneStatisticaEnum, String> toDistribuzioneTokenClaim = new HashMap<>();
  222.     static {
  223.         Enums.toDistribuzioneTokenClaim.put(TokenClaimDistribuzioneStatisticaEnum.CLIENT_ID, CostantiExporter.CLAIM_CLIENT_ID);
  224.         Enums.toDistribuzioneTokenClaim.put(TokenClaimDistribuzioneStatisticaEnum.CLIENT_ID_PDND_INFORMAZIONI, CostantiExporter.CLAIM_PDND_ORGANIZATION_NAME);
  225.         Enums.toDistribuzioneTokenClaim.put(TokenClaimDistribuzioneStatisticaEnum.EMAIL, CostantiExporter.CLAIM_EMAIL);
  226.         Enums.toDistribuzioneTokenClaim.put(TokenClaimDistribuzioneStatisticaEnum.ISSUER, CostantiExporter.CLAIM_ISSUER);
  227.         Enums.toDistribuzioneTokenClaim.put(TokenClaimDistribuzioneStatisticaEnum.SUBJECT, CostantiExporter.CLAIM_SUBJECT);
  228.         Enums.toDistribuzioneTokenClaim.put(TokenClaimDistribuzioneStatisticaEnum.USERNAME, CostantiExporter.CLAIM_USERNAME);
  229.     }

  230.     public static final Map<UnitaTempoReportEnum, StatisticType> toStatisticType = new HashMap<>();
  231.     static {
  232.         Enums.toStatisticType.put(UnitaTempoReportEnum.GIORNALIERO, StatisticType.GIORNALIERA);
  233.         Enums.toStatisticType.put(UnitaTempoReportEnum.MENSILE, StatisticType.MENSILE);
  234.         Enums.toStatisticType.put(UnitaTempoReportEnum.ORARIO, StatisticType.ORARIA);
  235.         Enums.toStatisticType.put(UnitaTempoReportEnum.SETTIMANALE, StatisticType.SETTIMANALE);
  236.     }

  237.     public static final Map<TransazioneRuoloEnum, String> toTipologiaRuoloTransazione = new HashMap<>();
  238.     static {
  239.         Enums.toTipologiaRuoloTransazione.put(TransazioneRuoloEnum.EROGAZIONE, CostantiExporter.TIPOLOGIA_EROGAZIONE);
  240.         Enums.toTipologiaRuoloTransazione.put(TransazioneRuoloEnum.FRUIZIONE, CostantiExporter.TIPOLOGIA_FRUIZIONE);
  241.     }
  242.    
  243.     public static final Map<FiltroRicercaRuoloTransazioneEnum, String> toTipologiaFiltroRicercaRuoloTransazioneEnum = new HashMap<>();
  244.     static {
  245.         Enums.toTipologiaFiltroRicercaRuoloTransazioneEnum.put(FiltroRicercaRuoloTransazioneEnum.EROGAZIONE, CostantiExporter.TIPOLOGIA_EROGAZIONE);
  246.         Enums.toTipologiaFiltroRicercaRuoloTransazioneEnum.put(FiltroRicercaRuoloTransazioneEnum.FRUIZIONE, CostantiExporter.TIPOLOGIA_FRUIZIONE);
  247.         Enums.toTipologiaFiltroRicercaRuoloTransazioneEnum.put(FiltroRicercaRuoloTransazioneEnum.QUALSIASI, CostantiExporter.TIPOLOGIA_EROGAZIONE_FRUIZIONE);
  248.     }
  249.    
  250.     public static final String toTipoRicercaMittente(TipoFiltroMittenteEnum v) {
  251.         if (v == null) return null;
  252.        
  253.         switch (v) {
  254.         case EROGAZIONE_SOGGETTO: return CostantiExporter.TIPO_RICERCA_MITTENTE_SOGGETTO;
  255.         case FRUIZIONE_APPLICATIVO: return CostantiExporter.TIPO_RICERCA_MITTENTE_APPLICATIVO;
  256.         case EROGAZIONE_APPLICATIVO: return CostantiExporter.TIPO_RICERCA_MITTENTE_APPLICATIVO;
  257.         case IDENTIFICATIVO_AUTENTICATO: return CostantiExporter.TIPO_RICERCA_MITTENTE_IDENTIFICATIVO_AUTENTICATO;
  258.         case EROGAZIONE_TOKEN_INFO: return CostantiExporter.TIPO_RICERCA_MITTENTE_TOKEN_INFO;
  259.         case TOKEN_INFO: return CostantiExporter.TIPO_RICERCA_MITTENTE_TOKEN_INFO;
  260.         case INDIRIZZO_IP: return CostantiExporter.TIPO_RICERCA_MITTENTE_INDIRIZZO_IP;
  261.         default: return null;
  262.         }
  263.     }

  264.     public static final TipoCredenzialeMittente toTipoCredenzialeMittente(TokenClaimEnum v) {
  265.         if (v==null) return null;
  266.         switch (v) {
  267.         case CLIENT_ID: return TipoCredenzialeMittente.TOKEN_CLIENT_ID;
  268.         case EMAIL: return TipoCredenzialeMittente.TOKEN_EMAIL;
  269.         case ISSUER: return TipoCredenzialeMittente.TOKEN_ISSUER;
  270.         case SUBJECT: return TipoCredenzialeMittente.TOKEN_SUBJECT;
  271.         case USERNAME: return TipoCredenzialeMittente.TOKEN_USERNAME;
  272.         default: return null;
  273.         }
  274.     }
  275.    
  276.     public static final TipoCredenzialeMittente toTipoCredenzialeMittente(TokenClaimSearchEnum v) {
  277.         if (v==null) return null;
  278.         switch (v) {
  279.         case CLIENT_ID: return TipoCredenzialeMittente.TOKEN_CLIENT_ID;
  280.         case EMAIL: return TipoCredenzialeMittente.TOKEN_EMAIL;
  281.         case ISSUER: return TipoCredenzialeMittente.TOKEN_ISSUER;
  282.         case SUBJECT: return TipoCredenzialeMittente.TOKEN_SUBJECT;
  283.         case USERNAME: return TipoCredenzialeMittente.TOKEN_USERNAME;
  284.         case PDND_ORGANIZATION_NAME: return TipoCredenzialeMittente.PDND_ORGANIZATION_NAME;
  285.         default: return null;
  286.         }
  287.     }

  288. }