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.config.rs.server.api.impl;

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

  25. import org.openspcoop2.core.config.constants.TipoAutenticazione;
  26. import org.openspcoop2.core.config.constants.TipoGestioneCORS;
  27. import org.openspcoop2.core.config.rs.server.model.ContestoEnum;
  28. import org.openspcoop2.core.config.rs.server.model.FonteEnum;
  29. import org.openspcoop2.core.config.rs.server.model.FormatoRestEnum;
  30. import org.openspcoop2.core.config.rs.server.model.FormatoSoapEnum;
  31. import org.openspcoop2.core.config.rs.server.model.RateLimitingChiaveEnum;
  32. import org.openspcoop2.core.config.rs.server.model.RuoloAllegatoAPI;
  33. import org.openspcoop2.core.config.rs.server.model.RuoloAllegatoAPIImpl;
  34. import org.openspcoop2.core.config.rs.server.model.TipoApiEnum;
  35. import org.openspcoop2.core.config.rs.server.model.TipoAutenticazioneEnum;
  36. import org.openspcoop2.core.config.rs.server.model.TipoAutenticazionePrincipal;
  37. import org.openspcoop2.core.config.rs.server.model.TipoGestioneCorsEnum;
  38. import org.openspcoop2.core.config.rs.server.model.TipoSpecificaLivelloServizioEnum;
  39. import org.openspcoop2.core.config.rs.server.model.TipoSpecificaSemiformaleEnum;
  40. import org.openspcoop2.core.config.rs.server.model.TipoSpecificaSicurezzaEnum;
  41. import org.openspcoop2.core.controllo_traffico.constants.TipoFiltroApplicativo;
  42. import org.openspcoop2.core.registry.constants.CredenzialeTipo;
  43. import org.openspcoop2.core.registry.constants.FormatoSpecifica;
  44. import org.openspcoop2.core.registry.constants.ProfiloCollaborazione;
  45. import org.openspcoop2.core.registry.constants.RuoliDocumento;
  46. import org.openspcoop2.core.registry.constants.RuoloContesto;
  47. import org.openspcoop2.core.registry.constants.RuoloTipologia;
  48. import org.openspcoop2.core.registry.constants.ScopeContesto;
  49. import org.openspcoop2.core.registry.constants.TipiDocumentoLivelloServizio;
  50. import org.openspcoop2.core.registry.constants.TipiDocumentoSemiformale;
  51. import org.openspcoop2.core.registry.constants.TipiDocumentoSicurezza;
  52. import org.openspcoop2.message.constants.ServiceBinding;
  53. import org.openspcoop2.protocol.manifest.constants.InterfaceType;
  54. import org.openspcoop2.utils.service.beans.ProfiloCollaborazioneEnum;

  56. /**
  57.  * Enums
  58.  * 
  59.  * @author $Author$
  60.  * @version $Rev$, $Date$
  61.  * 
  62.  */
  63. public class Enums {
  64.     
  65.     public static final <E extends Enum<E>> E fromValue(Class<E> enumClass, String value) {
  66.     
  67.         E[] constants = enumClass.getEnumConstants();
  68.         if  (constants == null)
  69.             throw new IllegalArgumentException("La classe passata non รจ un'enumerazione");
  70.         
  71.         for ( E e : constants) {
  72.             if (String.valueOf(e.toString()).equals(value.trim())) {
  73.                 return e;
  74.             }
  75.         }
  76.         
  77.         return null;
  78.     }
  79.     

  81.     //RuoloAllegatoAPIImpl -> RuoiliDocumento
  82.     //public static final Map<RuoloAllegatoAPIImpl,RuoliDocumento> 
  83.     
  84.     public static final Map<FonteEnum, RuoloTipologia> ruoloTipologiaFromRest = new HashMap<FonteEnum, RuoloTipologia>();
  85.     static {
  86.         Enums.ruoloTipologiaFromRest.put(FonteEnum.ESTERNA, RuoloTipologia.ESTERNO);
  87.         Enums.ruoloTipologiaFromRest.put(FonteEnum.QUALSIASI, RuoloTipologia.QUALSIASI);
  88.         Enums.ruoloTipologiaFromRest.put(FonteEnum.REGISTRO, RuoloTipologia.INTERNO);
  89.     }
  90.     public static final Map<FonteEnum, org.openspcoop2.core.config.constants.RuoloTipologia> ruoloTipologiaConfigFromRest = new HashMap<FonteEnum, org.openspcoop2.core.config.constants.RuoloTipologia>();
  91.     static {
  92.         Enums.ruoloTipologiaConfigFromRest.put(FonteEnum.ESTERNA, org.openspcoop2.core.config.constants.RuoloTipologia.ESTERNO);
  93.         Enums.ruoloTipologiaConfigFromRest.put(FonteEnum.QUALSIASI, org.openspcoop2.core.config.constants.RuoloTipologia.QUALSIASI);
  94.         Enums.ruoloTipologiaConfigFromRest.put(FonteEnum.REGISTRO, org.openspcoop2.core.config.constants.RuoloTipologia.INTERNO);
  95.     }
  96.     
  97.     
  98.     public static final Map<TipoAutenticazioneEnum, TipoAutenticazione> tipoAutenticazioneFromRest = new HashMap<TipoAutenticazioneEnum, TipoAutenticazione>();
  99.     static {
  100.         Enums.tipoAutenticazioneFromRest.put(TipoAutenticazioneEnum.DISABILITATO, TipoAutenticazione.DISABILITATO);
  101.         Enums.tipoAutenticazioneFromRest.put(TipoAutenticazioneEnum.HTTP_BASIC, TipoAutenticazione.BASIC);
  102.         Enums.tipoAutenticazioneFromRest.put(TipoAutenticazioneEnum.HTTPS, TipoAutenticazione.SSL);
  103.         Enums.tipoAutenticazioneFromRest.put(TipoAutenticazioneEnum.PRINCIPAL, TipoAutenticazione.PRINCIPAL);
  104.         Enums.tipoAutenticazioneFromRest.put(TipoAutenticazioneEnum.API_KEY, TipoAutenticazione.APIKEY);
  105.     }
  106.     
  107.     public static final Map<TipoAutenticazionePrincipal, org.openspcoop2.core.config.constants.TipoAutenticazionePrincipal> tipoAutenticazionePrincipalFromRest = new HashMap<>();
  108.     static {
  109.         Enums.tipoAutenticazionePrincipalFromRest.put(TipoAutenticazionePrincipal.CONTAINER, org.openspcoop2.core.config.constants.TipoAutenticazionePrincipal.CONTAINER);
  110.         Enums.tipoAutenticazionePrincipalFromRest.put(TipoAutenticazionePrincipal.FORM_BASED, org.openspcoop2.core.config.constants.TipoAutenticazionePrincipal.FORM);
  111.         Enums.tipoAutenticazionePrincipalFromRest.put(TipoAutenticazionePrincipal.HEADER_BASED, org.openspcoop2.core.config.constants.TipoAutenticazionePrincipal.HEADER);
  112.         Enums.tipoAutenticazionePrincipalFromRest.put(TipoAutenticazionePrincipal.IP_ADDRESS, org.openspcoop2.core.config.constants.TipoAutenticazionePrincipal.INDIRIZZO_IP);
  113.         // TODO: aggiungere all'API
  114.         Enums.tipoAutenticazionePrincipalFromRest.put(TipoAutenticazionePrincipal.IP_ADDRESS_FORWARDED_FOR, org.openspcoop2.core.config.constants.TipoAutenticazionePrincipal.INDIRIZZO_IP_X_FORWARDED_FOR);
  115.         Enums.tipoAutenticazionePrincipalFromRest.put(TipoAutenticazionePrincipal.URL_BASED, org.openspcoop2.core.config.constants.TipoAutenticazionePrincipal.URL);
  116.         Enums.tipoAutenticazionePrincipalFromRest.put(TipoAutenticazionePrincipal.TOKEN, org.openspcoop2.core.config.constants.TipoAutenticazionePrincipal.TOKEN);
  117.     }
  118.     
  119.     public static final <T1,T2> Map<T1,T2> dualizeMap(Map<T2,T1> map) {
  120.         HashMap<T1,T2> ret = new HashMap<T1,T2>();
  121.         
  122.         map.forEach( (t2, t1) -> ret.put(t1, t2));
  123.         
  124.         return ret;
  125.     }
  126.     
  127.     
  128.     public static final Map<TipoApiEnum,ServiceBinding> serviceBindingFromTipo = new HashMap<TipoApiEnum,ServiceBinding>();
  129.     static {
  130.         Enums.serviceBindingFromTipo.put(TipoApiEnum.REST, ServiceBinding.REST);
  131.         Enums.serviceBindingFromTipo.put(TipoApiEnum.SOAP, ServiceBinding.SOAP);
  132.     }
  133.     
  134.     
  135.     public static final Map<FormatoSoapEnum,FormatoSpecifica> formatoSpecificaFromSoap = new HashMap<FormatoSoapEnum,FormatoSpecifica>();
  136.     static {
  137.         Enums.formatoSpecificaFromSoap.put(FormatoSoapEnum._1, FormatoSpecifica.WSDL_11);
  138.     }
  139.     
  140.     
  141.     public static final Map<FormatoSpecifica,FormatoSoapEnum> formatoSoapFromSpecifica = new HashMap<FormatoSpecifica,FormatoSoapEnum>();
  142.     static {
  143.         Enums.formatoSpecificaFromSoap.forEach( (soapenum, fspec) -> Enums.formatoSoapFromSpecifica.put(fspec,soapenum) );
  144.     }
  145.     
  146.     
  147.     public static final Map<FormatoRestEnum,FormatoSpecifica> formatoSpecificaFromRest = new HashMap<FormatoRestEnum,FormatoSpecifica>();
  148.     static {
  149.         Enums.formatoSpecificaFromRest.put(FormatoRestEnum.OPENAPI3_0, FormatoSpecifica.OPEN_API_3);
  150.         Enums.formatoSpecificaFromRest.put(FormatoRestEnum.SWAGGER2_0, FormatoSpecifica.SWAGGER_2);
  151.         Enums.formatoSpecificaFromRest.put(FormatoRestEnum.WADL, FormatoSpecifica.WADL);
  152.     }
  153.     
  154.     
  155.     public static final Map<FormatoSpecifica,FormatoRestEnum> formatoRestFromSpecifica = new HashMap<FormatoSpecifica,FormatoRestEnum>();
  156.     static {
  157.         Enums.formatoSpecificaFromRest.forEach( (fr, fs) -> Enums.formatoRestFromSpecifica.put(fs, fr));
  158.     }
  159.         

  161.     public static final Map<FormatoSpecifica,InterfaceType> interfaceTypeFromFormatoSpecifica = new HashMap<FormatoSpecifica,InterfaceType>();
  162.     static {
  163.         Enums.interfaceTypeFromFormatoSpecifica.put(FormatoSpecifica.OPEN_API_3, InterfaceType.OPEN_API_3);
  164.         Enums.interfaceTypeFromFormatoSpecifica.put(FormatoSpecifica.SWAGGER_2, InterfaceType.SWAGGER_2);
  165.         Enums.interfaceTypeFromFormatoSpecifica.put(FormatoSpecifica.WADL, InterfaceType.WADL);
  166.         Enums.interfaceTypeFromFormatoSpecifica.put(FormatoSpecifica.WSDL_11, InterfaceType.WSDL_11);
  167.     }
  168.     
  169.     
  170.     public static final Map<RuoloAllegatoAPI,RuoliDocumento> ruoliDocumentoFromApi = new HashMap<RuoloAllegatoAPI,RuoliDocumento>();
  171.     static {
  172.         Enums.ruoliDocumentoFromApi.put(RuoloAllegatoAPI.ALLEGATO, RuoliDocumento.allegato);
  173.         Enums.ruoliDocumentoFromApi.put(RuoloAllegatoAPI.SPECIFICASEMIFORMALE, RuoliDocumento.specificaSemiformale);
  174.     }
  175.     
  176.     
  177.     public static final Map<RuoliDocumento,RuoloAllegatoAPI> ruoliApiFromDocumento = new HashMap<RuoliDocumento,RuoloAllegatoAPI>();
  178.     static {
  179.         Enums.ruoliDocumentoFromApi.forEach( (ra,rd) -> Enums.ruoliApiFromDocumento.put(rd, ra));
  180.     }
  181.     
  182.     public static final Map<RuoloAllegatoAPIImpl,RuoliDocumento> ruoliDocumentoFromApiImpl = new HashMap<RuoloAllegatoAPIImpl,RuoliDocumento>();
  183.     static {
  184.         Enums.ruoliDocumentoFromApiImpl.put(RuoloAllegatoAPIImpl.ALLEGATO, RuoliDocumento.allegato);
  185.         Enums.ruoliDocumentoFromApiImpl.put(RuoloAllegatoAPIImpl.SPECIFICASEMIFORMALE, RuoliDocumento.specificaSemiformale);
  186.         Enums.ruoliDocumentoFromApiImpl.put(RuoloAllegatoAPIImpl.SPECIFICASICUREZZA, RuoliDocumento.specificaSicurezza);
  187.         Enums.ruoliDocumentoFromApiImpl.put(RuoloAllegatoAPIImpl.SPECIFICALIVELLOSERVIZIO, RuoliDocumento.specificaLivelloServizio);
  188.     }
  189.     
  190.     
  191.     
  192.     public static final Map<RuoliDocumento,RuoloAllegatoAPIImpl> ruoliApiImplFromDocumento = new HashMap<RuoliDocumento,RuoloAllegatoAPIImpl>();
  193.     static {
  194.         Enums.ruoliDocumentoFromApiImpl.forEach( (ra,rd) -> Enums.ruoliApiImplFromDocumento.put(rd, ra));
  195.     }


  198.     
  199.     public static final Map<TipoSpecificaSemiformaleEnum,TipiDocumentoSemiformale> tipoDocumentoSemiFormaleFromSpecifica = new HashMap<TipoSpecificaSemiformaleEnum,TipiDocumentoSemiformale>();
  200.     static {
  201.         Enums.tipoDocumentoSemiFormaleFromSpecifica.put(TipoSpecificaSemiformaleEnum.HTML, TipiDocumentoSemiformale.HTML);
  202.         Enums.tipoDocumentoSemiFormaleFromSpecifica.put(TipoSpecificaSemiformaleEnum.JSON, TipiDocumentoSemiformale.JSON);
  203.         Enums.tipoDocumentoSemiFormaleFromSpecifica.put(TipoSpecificaSemiformaleEnum.LINGUAGGIO_NATURALE, TipiDocumentoSemiformale.LINGUAGGIO_NATURALE);
  204.         Enums.tipoDocumentoSemiFormaleFromSpecifica.put(TipoSpecificaSemiformaleEnum.UML, TipiDocumentoSemiformale.UML);
  205.         Enums.tipoDocumentoSemiFormaleFromSpecifica.put(TipoSpecificaSemiformaleEnum.XML, TipiDocumentoSemiformale.XML);
  206.         Enums.tipoDocumentoSemiFormaleFromSpecifica.put(TipoSpecificaSemiformaleEnum.XSD, TipiDocumentoSemiformale.XSD);
  207.         Enums.tipoDocumentoSemiFormaleFromSpecifica.put(TipoSpecificaSemiformaleEnum.YAML, TipiDocumentoSemiformale.YAML);
  208.     }
  209.     
  210.     public static final Map<TipoSpecificaLivelloServizioEnum,TipiDocumentoLivelloServizio> tipoDocumentoLivelloServizioFromSpecifica = new HashMap<TipoSpecificaLivelloServizioEnum,TipiDocumentoLivelloServizio>();
  211.     static {
  212.         Enums.tipoDocumentoLivelloServizioFromSpecifica.put(TipoSpecificaLivelloServizioEnum.WS_AGREEMENT, TipiDocumentoLivelloServizio.WSAGREEMENT);
  213.         Enums.tipoDocumentoLivelloServizioFromSpecifica.put(TipoSpecificaLivelloServizioEnum.WSLA, TipiDocumentoLivelloServizio.WSLA);
  214.     }
  215.     
  216.     public static final Map<TipoSpecificaSicurezzaEnum,TipiDocumentoSicurezza> tipoDocumentoSicurezzaFromSpecifica = new HashMap<TipoSpecificaSicurezzaEnum,TipiDocumentoSicurezza>();
  217.     static {
  218.         Enums.tipoDocumentoSicurezzaFromSpecifica.put(TipoSpecificaSicurezzaEnum.WS_POLICY, TipiDocumentoSicurezza.WSPOLICY);
  219.         Enums.tipoDocumentoSicurezzaFromSpecifica.put(TipoSpecificaSicurezzaEnum.XACML_POLICY, TipiDocumentoSicurezza.XACML_POLICY);
  220.         Enums.tipoDocumentoSicurezzaFromSpecifica.put(TipoSpecificaSicurezzaEnum.LINGUAGGIO_NATURALE, TipiDocumentoSicurezza.LINGUAGGIO_NATURALE);
  221.     }
  222.     
  223.     
  224.     public static final Map<ProfiloCollaborazioneEnum,ProfiloCollaborazione> profiloCollaborazioneFromApiEnum = new HashMap<ProfiloCollaborazioneEnum,ProfiloCollaborazione>();
  225.     static {
  226.         Enums.profiloCollaborazioneFromApiEnum.put(ProfiloCollaborazioneEnum.ASINCRONOASIMMETRICO, ProfiloCollaborazione.ASINCRONO_ASIMMETRICO);
  227.         Enums.profiloCollaborazioneFromApiEnum.put(ProfiloCollaborazioneEnum.ASINCRONOSIMMETRICO, ProfiloCollaborazione.ASINCRONO_SIMMETRICO);
  228.         Enums.profiloCollaborazioneFromApiEnum.put(ProfiloCollaborazioneEnum.ONEWAY, ProfiloCollaborazione.ONEWAY);
  229.         Enums.profiloCollaborazioneFromApiEnum.put(ProfiloCollaborazioneEnum.SINCRONO, ProfiloCollaborazione.SINCRONO);
  230.     }
  231.     
  232.     
  233.     public static final Map<ProfiloCollaborazione,ProfiloCollaborazioneEnum> profiloCollaborazioneApiFromRegistro = new HashMap<ProfiloCollaborazione,ProfiloCollaborazioneEnum>();
  234.     static {
  235.         Enums.profiloCollaborazioneFromApiEnum.forEach( (a,r) -> Enums.profiloCollaborazioneApiFromRegistro.put(r, a));
  236.     }


  239.     public static final Map<ContestoEnum,ScopeContesto> apiContestoToRegistroContesto = new HashMap<>();
  240.     static {
  241.         Enums.apiContestoToRegistroContesto.put(ContestoEnum.EROGAZIONE,ScopeContesto.PORTA_APPLICATIVA);
  242.         Enums.apiContestoToRegistroContesto.put(ContestoEnum.FRUIZIONE,ScopeContesto.PORTA_DELEGATA);
  243.         Enums.apiContestoToRegistroContesto.put(ContestoEnum.QUALSIASI,ScopeContesto.QUALSIASI);
  244.     }
  245.     
  246.     
  247.     public static final Map<ScopeContesto,ContestoEnum> registroContestoToApiContesto = new HashMap<>();
  248.     static {
  249.         Enums.apiContestoToRegistroContesto.forEach( (ac,rc) -> Enums.registroContestoToApiContesto.put(rc, ac));
  250.     }
  251.     
  252.     
  253.     public static RuoloContesto apiContestoToRegistroContesto(ContestoEnum c) {
  254.         switch(c) {
  255.         case EROGAZIONE:    return RuoloContesto.PORTA_APPLICATIVA;
  256.         case FRUIZIONE:     return RuoloContesto.PORTA_DELEGATA;
  257.         case QUALSIASI:     return RuoloContesto.QUALSIASI;
  258.         default: throw new IllegalArgumentException("Contesto di configurazione ruoli sconosciuto: " + c.toString());
  259.         }
  260.     }


  263.     public static ContestoEnum registroContestoToApiContesto(RuoloContesto c) {
  264.         switch(c) {
  265.         case PORTA_APPLICATIVA: return ContestoEnum.EROGAZIONE;
  266.         case PORTA_DELEGATA: return ContestoEnum.FRUIZIONE;
  267.         case QUALSIASI: return ContestoEnum.QUALSIASI;
  268.         default: throw new IllegalArgumentException("Contesto di registro ruoli sconosciuto: " + c.toString());
  269.         }
  270.     }


  273.     public static FonteEnum registroTipologiaToApiFonte(RuoloTipologia tipo) {
  274.         switch (tipo) {
  275.         case ESTERNO: return FonteEnum.ESTERNA;
  276.         case INTERNO: return FonteEnum.REGISTRO;
  277.         case QUALSIASI: return FonteEnum.QUALSIASI;
  278.         default: throw new IllegalArgumentException("TipologiaRuolo sconociuta: " + tipo.toString());
  279.         }
  280.     }


  283.     public static RuoloTipologia apiFonteToRegistroTipologia(FonteEnum fonte) {
  284.         switch (fonte) {
  285.         case ESTERNA: return RuoloTipologia.ESTERNO;
  286.         case REGISTRO: return RuoloTipologia.INTERNO;
  287.         case QUALSIASI: return RuoloTipologia.QUALSIASI;
  288.         default: throw new IllegalArgumentException("Fonte del ruolo sconosciuta: " + fonte.toString());
  289.         }
  290.     }
  291.     
  292.     

  294.     public static final Map<TipoGestioneCorsEnum,TipoGestioneCORS> tipoGestioneCorsFromRest = new HashMap<TipoGestioneCorsEnum,TipoGestioneCORS>();
  295.     static {
  296.         Enums.tipoGestioneCorsFromRest.put(TipoGestioneCorsEnum.APPLICATIVO, TipoGestioneCORS.TRASPARENTE);
  297.         Enums.tipoGestioneCorsFromRest.put(TipoGestioneCorsEnum.GATEWAY, TipoGestioneCORS.GATEWAY);
  298.     }
  299.     
  300.     
  301.     public static final Map<RateLimitingChiaveEnum,TipoFiltroApplicativo> tipoFiltroApplicativo = new HashMap<RateLimitingChiaveEnum,TipoFiltroApplicativo>();
  302.     static {
  303.         tipoFiltroApplicativo.put(RateLimitingChiaveEnum.CONTENT_BASED, TipoFiltroApplicativo.CONTENT_BASED);
  304.         tipoFiltroApplicativo.put(RateLimitingChiaveEnum.FORM_BASED, TipoFiltroApplicativo.FORM_BASED);
  305.         tipoFiltroApplicativo.put(RateLimitingChiaveEnum.HEADER_BASED, TipoFiltroApplicativo.HEADER_BASED);
  306.         tipoFiltroApplicativo.put(RateLimitingChiaveEnum.PLUGIN_BASED, TipoFiltroApplicativo.PLUGIN_BASED);
  307.         tipoFiltroApplicativo.put(RateLimitingChiaveEnum.SOAP_ACTION_BASED, TipoFiltroApplicativo.SOAPACTION_BASED);
  308.         tipoFiltroApplicativo.put(RateLimitingChiaveEnum.INDIRIZZO_IP, TipoFiltroApplicativo.INDIRIZZO_IP);
  309.         tipoFiltroApplicativo.put(RateLimitingChiaveEnum.INDIRIZZO_IP_FORWARDED, TipoFiltroApplicativo.INDIRIZZO_IP_FORWARDED);
  310.         tipoFiltroApplicativo.put(RateLimitingChiaveEnum.URL_BASED, TipoFiltroApplicativo.URLBASED);
  311.     }
  312.     
  313.     public static final Map<TipoFiltroApplicativo,RateLimitingChiaveEnum> rateLimitingChiaveEnum = new HashMap<TipoFiltroApplicativo,RateLimitingChiaveEnum>();
  314.     static {
  315.         tipoFiltroApplicativo.forEach( (a,r) -> rateLimitingChiaveEnum.put(r, a));
  316.     }
  317.     
  318.     public static final Map<TipoAutenticazioneEnum, CredenzialeTipo> credenzialeTipoFromTipoAutenticazione = new HashMap<TipoAutenticazioneEnum, CredenzialeTipo>();
  319.     static {
  320.         credenzialeTipoFromTipoAutenticazione.put(TipoAutenticazioneEnum.HTTP_BASIC, CredenzialeTipo.BASIC);
  321.         credenzialeTipoFromTipoAutenticazione.put(TipoAutenticazioneEnum.HTTPS,  CredenzialeTipo.SSL);
  322.         credenzialeTipoFromTipoAutenticazione.put(TipoAutenticazioneEnum.PRINCIPAL, CredenzialeTipo.PRINCIPAL);
  323.         credenzialeTipoFromTipoAutenticazione.put(TipoAutenticazioneEnum.API_KEY, CredenzialeTipo.APIKEY);
  324.     }

  326.     public static final TipoAutenticazione toTipoAutenticazione(TipoAutenticazioneEnum authn) {
  327.         if (authn == null) return null;
  328.         
  329.         switch(authn) {
  330.         case DISABILITATO: return TipoAutenticazione.DISABILITATO;
  331.         case HTTP_BASIC: return TipoAutenticazione.BASIC;
  332.         case HTTPS: return TipoAutenticazione.SSL;
  333.         case PRINCIPAL: return TipoAutenticazione.PRINCIPAL;
  334.         case API_KEY: return TipoAutenticazione.APIKEY;
  335.         default: return null;
  336.         }
  337.         
  338.     }
  339.     
  340. }
Created with JaCoCo 0.8.8.202204050719