ErroriProperties.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.protocol.utils;

  23. import java.util.Enumeration;
  24. import java.util.Properties;
  25. import java.util.concurrent.ConcurrentHashMap;

  27. import org.openspcoop2.message.constants.IntegrationError;
  28. import org.openspcoop2.protocol.sdk.ProtocolException;
  29. import org.openspcoop2.protocol.sdk.constants.CostantiProtocollo;
  30. import org.openspcoop2.protocol.sdk.constants.IntegrationFunctionError;
  31. import org.openspcoop2.utils.LoggerWrapperFactory;
  32. import org.openspcoop2.utils.resources.Loader;
  33. import org.slf4j.Logger;

  35. /**
  36.  * Classe che gestisce il file di properties 'errori.properties'
  37.  *
  38.  * @author Poli Andrea (apoli@link.it)
  39.  * @author $Author$
  40.  * @version $Rev$, $Date$
  41.  */
  42. public class ErroriProperties {

  44.     // 400
  45.     private static boolean FORCE_SPECIFIC_ERROR_TYPE_FOR_INTERNAL_BAD_REQUEST = false;
  46.     // 502
  47.     private static boolean FORCE_SPECIFIC_ERROR_TYPE_FOR_BAD_RESPONSE = false;
  48.     private static boolean FORCE_SPECIFIC_ERROR_TYPE_FOR_INTERNAL_RESPONSE_ERROR = false;
  49.     // 503
  50.     private static boolean FORCE_SPECIFIC_ERROR_TYPE_FOR_INTERNAL_ERROR = false;

  52.     // 400
  53.     public static boolean isFORCE_SPECIFIC_ERROR_TYPE_FOR_INTERNAL_BAD_REQUEST() {
  54.         return FORCE_SPECIFIC_ERROR_TYPE_FOR_INTERNAL_BAD_REQUEST;
  55.     }
  56.     public static void setFORCE_SPECIFIC_ERROR_TYPE_FOR_INTERNAL_BAD_REQUEST(
  57.             boolean fORCE_SPECIFIC_ERROR_TYPE_FOR_INTERNAL_BAD_REQUEST,
  58.             String confDir,Logger log,Loader loader) throws ProtocolException {
  59.         FORCE_SPECIFIC_ERROR_TYPE_FOR_INTERNAL_BAD_REQUEST = fORCE_SPECIFIC_ERROR_TYPE_FOR_INTERNAL_BAD_REQUEST;
  60.         reInit(confDir, log, loader);
  61.     }
  62.     
  63.     public static boolean isFORCE_SPECIFIC_ERROR_TYPE_FOR_BAD_RESPONSE() {
  64.         return FORCE_SPECIFIC_ERROR_TYPE_FOR_BAD_RESPONSE;
  65.     }
  66.     public static void setFORCE_SPECIFIC_ERROR_TYPE_FOR_BAD_RESPONSE(
  67.             boolean fORCE_SPECIFIC_ERROR_TYPE_FOR_BAD_RESPONSE,
  68.             String confDir,Logger log,Loader loader) throws ProtocolException {
  69.         FORCE_SPECIFIC_ERROR_TYPE_FOR_BAD_RESPONSE = fORCE_SPECIFIC_ERROR_TYPE_FOR_BAD_RESPONSE;
  70.         reInit(confDir, log, loader);
  71.     }

  73.     public static boolean isFORCE_SPECIFIC_ERROR_TYPE_FOR_INTERNAL_RESPONSE_ERROR() {
  74.         return FORCE_SPECIFIC_ERROR_TYPE_FOR_INTERNAL_RESPONSE_ERROR;
  75.     }
  76.     public static void setFORCE_SPECIFIC_ERROR_TYPE_FOR_INTERNAL_RESPONSE_ERROR(
  77.             boolean fORCE_SPECIFIC_ERROR_TYPE_FOR_INTERNAL_RESPONSE_ERROR,
  78.             String confDir,Logger log,Loader loader) throws ProtocolException {
  79.         FORCE_SPECIFIC_ERROR_TYPE_FOR_INTERNAL_RESPONSE_ERROR = fORCE_SPECIFIC_ERROR_TYPE_FOR_INTERNAL_RESPONSE_ERROR;
  80.         reInit(confDir, log, loader);
  81.     }

  83.     public static boolean isFORCE_SPECIFIC_ERROR_TYPE_FOR_INTERNAL_ERROR() {
  84.         return FORCE_SPECIFIC_ERROR_TYPE_FOR_INTERNAL_ERROR;
  85.     }
  86.     public static void setFORCE_SPECIFIC_ERROR_TYPE_FOR_INTERNAL_ERROR(
  87.             boolean fORCE_SPECIFIC_ERROR_TYPE_FOR_INTERNAL_ERROR,
  88.             String confDir,Logger log,Loader loader) throws ProtocolException {
  89.         FORCE_SPECIFIC_ERROR_TYPE_FOR_INTERNAL_ERROR = fORCE_SPECIFIC_ERROR_TYPE_FOR_INTERNAL_ERROR;
  90.         reInit(confDir, log, loader);
  91.     }
  92.     
  93.     private static synchronized void reInit(String confDir,Logger log,Loader loader) throws ProtocolException {
  94.         ErroriProperties erroriPropertiesNew = new ErroriProperties(confDir, log);
  95.         erroriPropertiesNew.validaConfigurazione(loader);
  96.         ErroriProperties.erroriProperties = erroriPropertiesNew; // switch
  97.     } 
  98.     
  99.     
  100.     /** Logger utilizzato per errori eventuali. */
  101.     private Logger log = null;


  104.     /** Copia Statica */
  105.     private static ErroriProperties erroriProperties = null;

  107.     /* ********  F I E L D S  P R I V A T I  ******** */

  109.     /** Reader delle proprieta' impostate nel file 'errori.properties' */
  110.     private ErroriInstanceProperties reader;


  113.     


  116.     /* ********  C O S T R U T T O R E  ******** */

  118.     /**
  119.      * Viene chiamato in causa per istanziare il properties reader
  120.      *
  121.      * 
  122.      */
  123.     private ErroriProperties(String confDir,Logger log) throws ProtocolException{

  125.         if(log != null)
  126.             this.log = log;
  127.         else
  128.             this.log = LoggerWrapperFactory.getLogger(ErroriProperties.class);

  130.         /* ---- Lettura del cammino del file di configurazione ---- */

  132.         Properties propertiesReader = new Properties();
  133.         java.io.InputStream properties = null;
  134.         try{  
  135.             properties = ErroriProperties.class.getResourceAsStream("/org/openspcoop2/protocol/utils/errori.properties");
  136.             if(properties==null){
  137.                 throw new Exception("File '/org/openspcoop2/protocol/utils/errori.properties' not found");
  138.             }
  139.             propertiesReader.load(properties);
  140.         }catch(Exception e) {
  141.             this.log.error("Riscontrato errore durante la lettura del file 'org/openspcoop2/protocol/utils/errori.properties': "+e.getMessage());
  142.             throw new ProtocolException("ErroriProperties initialize error: "+e.getMessage(),e);
  143.         }finally{
  144.             try{
  145.                 if(properties!=null)
  146.                     properties.close();
  147.             }catch(Throwable er){
  148.                 // close
  149.             }
  150.         }
  151.         try{
  152.             this.reader = new ErroriInstanceProperties(confDir, propertiesReader, this.log);
  153.         }catch(Exception e){
  154.             throw new ProtocolException(e.getMessage(),e);
  155.         }

  157.     }

  159.     /**
  160.      * Il Metodo si occupa di inizializzare il propertiesReader 
  161.      *
  162.      * 
  163.      */
  164.     public static synchronized void initialize(String confDir,Logger log,Loader loader) throws ProtocolException{

  166.         if(ErroriProperties.erroriProperties==null){
  167.             
  168.             ErroriProperties.erroriProperties = new ErroriProperties(confDir, log);
  169.             erroriProperties.validaConfigurazione(loader);
  170.                         
  171.         }

  173.     }

  175.     /**
  176.      * Ritorna l'istanza di questa classe
  177.      *
  178.      * @return Istanza di OpenSPCoopProperties
  179.      * @throws Exception 
  180.      * 
  181.      */
  182.     public static ErroriProperties getInstance(Logger log) throws ProtocolException{

  184.         if(ErroriProperties.erroriProperties==null) {
  185.             // spotbugs warning 'SING_SINGLETON_GETTER_NOT_SYNCHRONIZED': l'istanza viene creata allo startup
  186.             synchronized (ErroriProperties.class) {
  187.                 throw new ProtocolException("ErroriProperties not initialized (use init method in factory)");
  188.             }
  189.         }

  191.         return ErroriProperties.erroriProperties;
  192.     }




  197.     public void validaConfigurazione(Loader loader) throws ProtocolException  { 
  198.         try{  
  199.             
  200.             getPrefixWebSite();
  201.             
  202.             getPrefixWebSiteErrorPage();
  203.             
  204.             initMapWrapped();
  205.             
  206.             IntegrationFunctionError [] lista = IntegrationFunctionError.values();
  207.             for (IntegrationFunctionError integrationFunctionError : lista) {
  208.                 
  209.                 getIntegrationError(integrationFunctionError);
  210.                 
  211.                 getErrorType(integrationFunctionError);

  213.                 getGenericDetails(integrationFunctionError);
  214.                 
  215.                 isForceGenericDetails(integrationFunctionError);
  216.                 
  217.                 getWebSite(integrationFunctionError);
  218.                 
  219.             }
  220.             
  221.             
  222.         }catch(java.lang.Exception e) {
  223.             String msg = "Riscontrato errore durante la validazione della proprieta' degli errori, "+e.getMessage();
  224.             this.log.error(msg,e);
  225.             throw new ProtocolException(msg,e);
  226.         }
  227.     }

  229.     
  230.     
  231.     /* **** CONVERTER **** */

  233.     private Boolean typeEnabled = null;
  234.     public boolean isTypeEnabled() throws ProtocolException {
  235.         if(this.typeEnabled==null) {
  236.             this.initTypeEnabled();
  237.         }
  238.         return this.typeEnabled;
  239.     }
  240.     private synchronized void initTypeEnabled() throws ProtocolException {
  241.         if(this.typeEnabled==null) {
  242.             this.typeEnabled = getBooleanProperty("type.enabled");
  243.         }
  244.     }
  245.     
  246.     
  247.     
  248.     
  249.     private String webSite = null;
  250.     public String getPrefixWebSite() throws ProtocolException {
  251.         if(this.webSite==null) {
  252.             this.initPrefixWebSite();
  253.         }
  254.         return this.webSite;
  255.     }
  256.     private synchronized void initPrefixWebSite() throws ProtocolException {
  257.         if(this.webSite==null) {
  258.             this.webSite = getProperty("webSite");
  259.             if(this.webSite.endsWith("/")) {
  260.                 this.webSite = this.webSite.substring(0, this.webSite.length()-1); 
  261.             }
  262.         }
  263.     }
  264.     
  265.     

  267.     private String webSiteErrorPage = null;
  268.     public String getPrefixWebSiteErrorPage() throws ProtocolException {
  269.         if(this.webSiteErrorPage==null) {
  270.             this.initPrefixWebSiteErrorPage();
  271.         }
  272.         return this.webSiteErrorPage;
  273.     }
  274.     private synchronized void initPrefixWebSiteErrorPage() throws ProtocolException {
  275.         if(this.webSiteErrorPage==null) {
  276.             this.webSiteErrorPage = getProperty("webSite.errorPage");
  277.         }
  278.     }
  279.     
  280.     
  281.     
  282.     private ConcurrentHashMap<IntegrationFunctionError,Boolean> mapWrapped= null;
  283.     public Boolean isWrapped(IntegrationFunctionError functionError) throws ProtocolException {
  284.         if(this.mapWrapped==null){
  285.             this.initMapWrapped();
  286.         }
  287.         return this.mapWrapped.get(functionError);
  288.     }
  289.     private synchronized void initMapWrapped() throws ProtocolException {
  290.         if(this.mapWrapped==null){
  291.             this.mapWrapped = new ConcurrentHashMap<IntegrationFunctionError, Boolean>();
  292.             IntegrationFunctionError [] lista = IntegrationFunctionError.wrappedValues();
  293.             for (IntegrationFunctionError integrationFunctionError : lista) {
  294.                 
  295.                 String pName = integrationFunctionError.name()+".enabled";
  296.                 try{
  297.                     Boolean p = null;
  298.                     if(IntegrationFunctionError.WRAP_400_INTERNAL_BAD_REQUEST.equals(integrationFunctionError)){
  299.                         if(FORCE_SPECIFIC_ERROR_TYPE_FOR_INTERNAL_BAD_REQUEST) {
  300.                             p = false;
  301.                         }
  302.                         else {
  303.                             p = getBooleanProperty(pName);
  304.                         }
  305.                     }
  306.                     else if(IntegrationFunctionError.WRAP_502_BAD_RESPONSE.equals(integrationFunctionError)){
  307.                         if(FORCE_SPECIFIC_ERROR_TYPE_FOR_BAD_RESPONSE) {
  308.                             p = false;
  309.                         }
  310.                         else {
  311.                             p = getBooleanProperty(pName);
  312.                         }
  313.                     }
  314.                     else if(IntegrationFunctionError.WRAP_502_INTERNAL_RESPONSE_ERROR.equals(integrationFunctionError)){
  315.                         if(FORCE_SPECIFIC_ERROR_TYPE_FOR_INTERNAL_RESPONSE_ERROR) {
  316.                             p = false;
  317.                         }
  318.                         else {
  319.                             p = getBooleanProperty(pName);
  320.                         }
  321.                     }
  322.                     else if(IntegrationFunctionError.WRAP_503_INTERNAL_ERROR.equals(integrationFunctionError)){
  323.                         if(FORCE_SPECIFIC_ERROR_TYPE_FOR_INTERNAL_ERROR) {
  324.                             p = false;
  325.                         }
  326.                         else {
  327.                             p = getBooleanProperty(pName);
  328.                         }
  329.                     }
  330.                     else {
  331.                         // caso non esistente
  332.                         p = getBooleanProperty(pName);
  333.                     }
  334.                     this.mapWrapped.put(integrationFunctionError, p);
  335.                 }catch(Exception e){
  336.                     throw new ProtocolException("Errore durante la gestione del codice ["+integrationFunctionError.name()+"]: "+e.getMessage(),e);
  337.                 }
  338.             }
  339.         }
  340.     }
  341.     
  342.     
  343.     
  344.     
  345.     
  346.     private ConcurrentHashMap<IntegrationFunctionError,IntegrationError> mapIntegrationError= null;
  347.     private ConcurrentHashMap<IntegrationFunctionError,IntegrationError> mapIntegrationError_noWrap= null;
  348.     public IntegrationError getIntegrationError(IntegrationFunctionError functionError) throws ProtocolException {
  349.         if(this.mapIntegrationError==null){
  350.             this.initMapIntegrationError();
  351.         }
  352.         return this.mapIntegrationError.get(functionError);
  353.     }
  354.     public IntegrationError getIntegrationError_noWrap(IntegrationFunctionError functionError) throws ProtocolException {
  355.         if(this.mapIntegrationError_noWrap==null){
  356.             this.initMapIntegrationError();
  357.         }
  358.         return this.mapIntegrationError_noWrap.get(functionError);
  359.     }
  360.     private synchronized void initMapIntegrationError() throws ProtocolException {
  361.         if(this.mapIntegrationError==null){
  362.             this.mapIntegrationError = new ConcurrentHashMap<IntegrationFunctionError, IntegrationError>();
  363.             this.mapIntegrationError_noWrap = new ConcurrentHashMap<IntegrationFunctionError, IntegrationError>();
  364.             IntegrationFunctionError [] lista = IntegrationFunctionError.values();
  365.             for (IntegrationFunctionError integrationFunctionError : lista) {
  366.                 String pName = integrationFunctionError.name()+".errorCode";
  367.                 try{
  368.                     String p = getProperty(pName);
  369.                     IntegrationError integrationError = IntegrationError.valueOf(p);
  370.                     IntegrationError integrationError_noWrap = IntegrationError.valueOf(p);
  371.                     
  372.                     if(integrationFunctionError.isWrapBadRequest()) {
  373.                         if(isWrapped(IntegrationFunctionError.WRAP_400_INTERNAL_BAD_REQUEST)) {
  374.                             String pWrappedName = IntegrationFunctionError.WRAP_400_INTERNAL_BAD_REQUEST.name()+".errorCode";
  375.                             p = getProperty(pWrappedName);
  376.                             integrationError = IntegrationError.valueOf(p);
  377.                         }
  378.                     }
  379.                     else if(integrationFunctionError.isWrapBadResponse(integrationError)) {
  380.                         if(isWrapped(IntegrationFunctionError.WRAP_502_BAD_RESPONSE)) {
  381.                             String pWrappedName = IntegrationFunctionError.WRAP_502_BAD_RESPONSE.name()+".errorCode";
  382.                             p = getProperty(pWrappedName);
  383.                             integrationError = IntegrationError.valueOf(p);
  384.                         }
  385.                     }
  386.                     else if(integrationFunctionError.isWrapInternalResponseError(integrationError)) {
  387.                         if(isWrapped(IntegrationFunctionError.WRAP_502_INTERNAL_RESPONSE_ERROR)) {
  388.                             String pWrappedName = IntegrationFunctionError.WRAP_502_INTERNAL_RESPONSE_ERROR.name()+".errorCode";
  389.                             p = getProperty(pWrappedName);
  390.                             integrationError = IntegrationError.valueOf(p);
  391.                         }
  392.                     }
  393.                     else if(integrationFunctionError.isWrapInternalError()) {
  394.                         if(isWrapped(IntegrationFunctionError.WRAP_503_INTERNAL_ERROR)) {
  395.                             String pWrappedName = IntegrationFunctionError.WRAP_503_INTERNAL_ERROR.name()+".errorCode";
  396.                             p = getProperty(pWrappedName);
  397.                             integrationError = IntegrationError.valueOf(p);
  398.                         }
  399.                     }
  400.                     
  401.                     this.mapIntegrationError.put(integrationFunctionError, integrationError);
  402.                     this.mapIntegrationError_noWrap.put(integrationFunctionError, integrationError_noWrap);
  403.                     
  404.                 }catch(Exception e){
  405.                     throw new ProtocolException("Errore durante la gestione del codice ["+integrationFunctionError.name()+"]: "+e.getMessage(),e);
  406.                 }
  407.             }
  408.         }
  409.     }
  410.     
  411.     
  412.     
  413.     private ConcurrentHashMap<IntegrationFunctionError,String> mapErrorType= null;
  414.     private ConcurrentHashMap<IntegrationFunctionError,String> mapErrorType_noWrap= null;
  415.     public String getErrorType(IntegrationFunctionError functionError) throws ProtocolException {
  416.         if(this.mapErrorType==null){
  417.             this.initMapErrorType();
  418.         }
  419.         return this.mapErrorType.get(functionError);
  420.     }
  421.     public String getErrorType_noWrap(IntegrationFunctionError functionError) throws ProtocolException {
  422.         if(this.mapErrorType_noWrap==null){
  423.             this.initMapErrorType();
  424.         }
  425.         return this.mapErrorType_noWrap.get(functionError);
  426.     }
  427.     public IntegrationFunctionError convertToIntegrationFunctionError(String errorType) throws ProtocolException {
  428.         return this._convertToIntegrationFunctionError(errorType);
  429.     }
  430.     private IntegrationFunctionError _convertToIntegrationFunctionError(String errorType) throws ProtocolException {
  431.         if(this.mapErrorType==null){
  432.             this.initMapErrorType();
  433.         }
  434.         Enumeration<IntegrationFunctionError> en = this.mapErrorType.keys();
  435.         while (en.hasMoreElements()) {
  436.             IntegrationFunctionError integrationFunctionError = (IntegrationFunctionError) en.nextElement();
  437.             String type = this.mapErrorType.get(integrationFunctionError);
  438.             if(type.equals(errorType)) {
  439.                 return integrationFunctionError;
  440.             }
  441.         }
  442.         throw new ProtocolException("GovWayErrorType '"+errorType+"' unknown");
  443.     }
  444.     public IntegrationFunctionError convertToIntegrationFunctionError_noWrap(String errorType) throws ProtocolException {
  445.         return this._convertToIntegrationFunctionError_noWrap(errorType);
  446.     }
  447.     private IntegrationFunctionError _convertToIntegrationFunctionError_noWrap(String errorType) throws ProtocolException {
  448.         if(this.mapErrorType_noWrap==null){
  449.             this.initMapErrorType();
  450.         }
  451.         Enumeration<IntegrationFunctionError> en = this.mapErrorType_noWrap.keys();
  452.         while (en.hasMoreElements()) {
  453.             IntegrationFunctionError integrationFunctionError = (IntegrationFunctionError) en.nextElement();
  454.             String type = this.mapErrorType_noWrap.get(integrationFunctionError);
  455.             if(type.equals(errorType)) {
  456.                 return integrationFunctionError;
  457.             }
  458.         }
  459.         throw new ProtocolException("GovWayErrorType '"+errorType+"' unknown");
  460.     }
  461.     private synchronized void initMapErrorType() throws ProtocolException {
  462.         if(this.mapErrorType==null){
  463.             this.mapErrorType = new ConcurrentHashMap<IntegrationFunctionError, String>();
  464.             this.mapErrorType_noWrap = new ConcurrentHashMap<IntegrationFunctionError, String>();
  465.             IntegrationFunctionError [] lista = IntegrationFunctionError.values();
  466.             for (IntegrationFunctionError integrationFunctionError : lista) {
  467.                 String pName = integrationFunctionError.name()+".errorType";
  468.                 try{
  469.                     String p = getProperty(pName);
  470.                     String p_noWrap = p;
  471.                     
  472.                     IntegrationError integrationError = this.mapIntegrationError_noWrap.get(integrationFunctionError);
  473.                     
  474.                     if(integrationFunctionError.isWrapBadRequest()) {
  475.                         if(isWrapped(IntegrationFunctionError.WRAP_400_INTERNAL_BAD_REQUEST)) {
  476.                             String pWrappedName = IntegrationFunctionError.WRAP_400_INTERNAL_BAD_REQUEST.name()+".errorType";
  477.                             p = getProperty(pWrappedName);
  478.                         }
  479.                     }
  480.                     else if(integrationFunctionError.isWrapBadResponse(integrationError)) {
  481.                         if(isWrapped(IntegrationFunctionError.WRAP_502_BAD_RESPONSE)) {
  482.                             String pWrappedName = IntegrationFunctionError.WRAP_502_BAD_RESPONSE.name()+".errorType";
  483.                             p = getProperty(pWrappedName);
  484.                         }
  485.                     }
  486.                     else if(integrationFunctionError.isWrapInternalResponseError(integrationError)) {
  487.                         if(isWrapped(IntegrationFunctionError.WRAP_502_INTERNAL_RESPONSE_ERROR)) {
  488.                             String pWrappedName = IntegrationFunctionError.WRAP_502_INTERNAL_RESPONSE_ERROR.name()+".errorType";
  489.                             p = getProperty(pWrappedName);
  490.                         }
  491.                     }
  492.                     else if(integrationFunctionError.isWrapInternalError()) {
  493.                         if(isWrapped(IntegrationFunctionError.WRAP_503_INTERNAL_ERROR)) {
  494.                             String pWrappedName = IntegrationFunctionError.WRAP_503_INTERNAL_ERROR.name()+".errorType";
  495.                             p = getProperty(pWrappedName);
  496.                         }
  497.                     }               
  498.                     
  499.                     this.mapErrorType.put(integrationFunctionError, p);
  500.                     this.mapErrorType_noWrap.put(integrationFunctionError, p_noWrap);
  501.                 }catch(Exception e){
  502.                     throw new ProtocolException("Errore durante la gestione del codice ["+integrationFunctionError.name()+"]: "+e.getMessage(),e);
  503.                 }
  504.             }
  505.         }
  506.     }
  507.     
  508.     
  509.     
  510.     private ConcurrentHashMap<IntegrationFunctionError,String> mapWebSite= null;
  511.     private ConcurrentHashMap<IntegrationFunctionError,String> mapWebSite_noWrap= null;
  512.     public String getWebSite(IntegrationFunctionError functionError) throws ProtocolException {
  513.         if(this.mapWebSite==null){
  514.             this.initMapWebSite();
  515.         }
  516.         return this.mapWebSite.get(functionError);
  517.     }
  518.     public String getWebSite_noWrap(IntegrationFunctionError functionError) throws ProtocolException {
  519.         if(this.mapWebSite_noWrap==null){
  520.             this.initMapWebSite();
  521.         }
  522.         return this.mapWebSite_noWrap.get(functionError);
  523.     }
  524.     private synchronized void initMapWebSite() throws ProtocolException {
  525.         if(this.mapWebSite==null){
  526.             this.mapWebSite = new ConcurrentHashMap<IntegrationFunctionError, String>();
  527.             this.mapWebSite_noWrap = new ConcurrentHashMap<IntegrationFunctionError, String>();
  528.             IntegrationFunctionError [] lista = IntegrationFunctionError.values();
  529.             for (IntegrationFunctionError integrationFunctionError : lista) {
  530.                 String pName = integrationFunctionError.name()+".webSite";
  531.                 try{
  532.                     String p = getOptionalProperty(pName);
  533.                     String p_noWrap = p;
  534.                     
  535.                     IntegrationError integrationError = this.mapIntegrationError_noWrap.get(integrationFunctionError);
  536.                     IntegrationError integrationError_noWrap = integrationError; 
  537.                     
  538.                     String integrationType = this.getErrorType(integrationFunctionError);
  539.                     String integrationType_noWrap = integrationType;                
  540.                     
  541.                     if(integrationFunctionError.isWrapBadRequest()) {
  542.                         if(isWrapped(IntegrationFunctionError.WRAP_400_INTERNAL_BAD_REQUEST)) {
  543.                             String pWrappedName = IntegrationFunctionError.WRAP_400_INTERNAL_BAD_REQUEST.name()+".webSite";
  544.                             p = getOptionalProperty(pWrappedName);
  545.                             integrationError = this.getIntegrationError(IntegrationFunctionError.WRAP_400_INTERNAL_BAD_REQUEST);
  546.                             integrationType = this.getErrorType(IntegrationFunctionError.WRAP_400_INTERNAL_BAD_REQUEST);
  547.                         }
  548.                     }
  549.                     else if(integrationFunctionError.isWrapBadResponse(integrationError)) {
  550.                         if(isWrapped(IntegrationFunctionError.WRAP_502_BAD_RESPONSE)) {
  551.                             String pWrappedName = IntegrationFunctionError.WRAP_502_BAD_RESPONSE.name()+".webSite";
  552.                             p = getOptionalProperty(pWrappedName);
  553.                             integrationError = this.getIntegrationError(IntegrationFunctionError.WRAP_502_BAD_RESPONSE);
  554.                             integrationType = this.getErrorType(IntegrationFunctionError.WRAP_502_BAD_RESPONSE);
  555.                         }
  556.                     }
  557.                     else if(integrationFunctionError.isWrapInternalResponseError(integrationError)) {
  558.                         if(isWrapped(IntegrationFunctionError.WRAP_502_INTERNAL_RESPONSE_ERROR)) {
  559.                             String pWrappedName = IntegrationFunctionError.WRAP_502_INTERNAL_RESPONSE_ERROR.name()+".webSite";
  560.                             p = getOptionalProperty(pWrappedName);
  561.                             integrationError = this.getIntegrationError(IntegrationFunctionError.WRAP_502_INTERNAL_RESPONSE_ERROR);
  562.                             integrationType = this.getErrorType(IntegrationFunctionError.WRAP_502_INTERNAL_RESPONSE_ERROR);
  563.                         }
  564.                     }
  565.                     else if(integrationFunctionError.isWrapInternalError()) {
  566.                         if(isWrapped(IntegrationFunctionError.WRAP_503_INTERNAL_ERROR)) {
  567.                             String pWrappedName = IntegrationFunctionError.WRAP_503_INTERNAL_ERROR.name()+".webSite";
  568.                             p = getOptionalProperty(pWrappedName);
  569.                             integrationError = this.getIntegrationError(IntegrationFunctionError.WRAP_503_INTERNAL_ERROR);
  570.                             integrationType = this.getErrorType(IntegrationFunctionError.WRAP_503_INTERNAL_ERROR);
  571.                         }
  572.                     }
  573.                     
  574.                     String site = this.getSite(p, integrationError, integrationType);
  575.                     this.mapWebSite.put(integrationFunctionError, site);
  576.                         
  577.                     String site_noWrap = this.getSite(p_noWrap, integrationError_noWrap, integrationType_noWrap);
  578.                     this.mapWebSite_noWrap.put(integrationFunctionError, site_noWrap);
  579.                     
  580.                 }catch(Exception e){
  581.                     throw new ProtocolException("Errore durante la gestione del codice ["+integrationFunctionError.name()+"]: "+e.getMessage(),e);
  582.                 }
  583.             }
  584.         }
  585.     }
  586.     private String getSite(String p, IntegrationError integrationError, String integrationType) {
  587.                 
  588.         String site = null;
  589.         if(p!=null) {
  590.             if(p.startsWith("http://") || p.startsWith("https://")) {
  591.                 return p;
  592.             }
  593.             else {
  594.                 if(p.startsWith("/")) {
  595.                     site = this.webSite + p; 
  596.                 }
  597.                 else {
  598.                     site = this.webSite + "/" + p; 
  599.                 }
  600.             }
  601.         }
  602.         else {
  603.             if(this.webSiteErrorPage.startsWith("/")) {
  604.                 site = this.webSite + this.webSiteErrorPage; 
  605.             }
  606.             else {
  607.                 site = this.webSite + "/" + this.webSiteErrorPage; 
  608.             }
  609.         }
  610.             
  611.         while(site.contains(CostantiProtocollo.OPENSPCOOP2_ERRORI_TEMPLATE_HTTP_CODE)) {
  612.             switch (integrationError) {
  613.             case BAD_REQUEST:
  614.                 site = site.replace(CostantiProtocollo.OPENSPCOOP2_ERRORI_TEMPLATE_HTTP_CODE, "400");
  615.                 break;
  616.             case AUTHENTICATION:
  617.                 site = site.replace(CostantiProtocollo.OPENSPCOOP2_ERRORI_TEMPLATE_HTTP_CODE, "401");
  618.                 break;
  619.             case AUTHORIZATION:
  620.                 site = site.replace(CostantiProtocollo.OPENSPCOOP2_ERRORI_TEMPLATE_HTTP_CODE, "403");
  621.                 break;
  622.             case NOT_FOUND:
  623.                 site = site.replace(CostantiProtocollo.OPENSPCOOP2_ERRORI_TEMPLATE_HTTP_CODE, "404");
  624.                 break;
  625.             case CONFLICT:
  626.                 site = site.replace(CostantiProtocollo.OPENSPCOOP2_ERRORI_TEMPLATE_HTTP_CODE, "409");
  627.                 break;
  628.             case REQUEST_TOO_LARGE:
  629.                 site = site.replace(CostantiProtocollo.OPENSPCOOP2_ERRORI_TEMPLATE_HTTP_CODE, "413");
  630.                 break;
  631.             case LIMIT_EXCEEDED:
  632.             case TOO_MANY_REQUESTS:
  633.                 site = site.replace(CostantiProtocollo.OPENSPCOOP2_ERRORI_TEMPLATE_HTTP_CODE, "429");
  634.                 break;
  635.             case BAD_RESPONSE:
  636.             case INTERNAL_RESPONSE_ERROR:
  637.                 site = site.replace(CostantiProtocollo.OPENSPCOOP2_ERRORI_TEMPLATE_HTTP_CODE, "502");
  638.                 break;
  639.             case SERVICE_UNAVAILABLE:
  640.             case INTERNAL_REQUEST_ERROR:
  641.                 site = site.replace(CostantiProtocollo.OPENSPCOOP2_ERRORI_TEMPLATE_HTTP_CODE, "503");
  642.                 break;
  643.             case ENDPOINT_REQUEST_TIMED_OUT:
  644.                 site = site.replace(CostantiProtocollo.OPENSPCOOP2_ERRORI_TEMPLATE_HTTP_CODE, "504");
  645.                 break;
  646.             case DEFAULT:
  647.                 site = site.replace(CostantiProtocollo.OPENSPCOOP2_ERRORI_TEMPLATE_HTTP_CODE, "503");
  648.                 break;
  649.             }   
  650.         }
  651.         
  652.         while(site.contains(CostantiProtocollo.OPENSPCOOP2_ERRORI_TEMPLATE_ERROR_CODE)) {
  653.             site = site.replace(CostantiProtocollo.OPENSPCOOP2_ERRORI_TEMPLATE_ERROR_CODE, integrationError.name());
  654.         }
  655.         
  656.         while(site.contains(CostantiProtocollo.OPENSPCOOP2_ERRORI_TEMPLATE_ERROR_TYPE)) {
  657.             site = site.replace(CostantiProtocollo.OPENSPCOOP2_ERRORI_TEMPLATE_ERROR_TYPE, integrationType);
  658.         }
  659.         
  660.         return site;
  661.     }
  662.     
  663.     
  664.     private ConcurrentHashMap<IntegrationFunctionError,String> mapGenericDetails= null;
  665.     private ConcurrentHashMap<IntegrationFunctionError,String> mapGenericDetails_noWrap= null;
  666.     public String getGenericDetails(IntegrationFunctionError functionError) throws ProtocolException {
  667.         if(this.mapGenericDetails==null){
  668.             this.initMapGenericDetails();
  669.         }
  670.         return this.mapGenericDetails.get(functionError);
  671.     }
  672.     public String getGenericDetails_noWrap(IntegrationFunctionError functionError) throws ProtocolException {
  673.         if(this.mapGenericDetails_noWrap==null){
  674.             this.initMapGenericDetails();
  675.         }
  676.         return this.mapGenericDetails_noWrap.get(functionError);
  677.     }
  678.     private synchronized void initMapGenericDetails() throws ProtocolException {
  679.         if(this.mapGenericDetails==null){
  680.             this.mapGenericDetails = new ConcurrentHashMap<IntegrationFunctionError, String>();
  681.             this.mapGenericDetails_noWrap = new ConcurrentHashMap<IntegrationFunctionError, String>();
  682.             IntegrationFunctionError [] lista = IntegrationFunctionError.values();
  683.             for (IntegrationFunctionError integrationFunctionError : lista) {
  684.                 String pName = integrationFunctionError.name()+".genericDetails";
  685.                 try{
  686.                     String p = getProperty(pName);
  687.                     String p_noWrap = p;
  688.                     
  689.                     IntegrationError integrationError = this.mapIntegrationError_noWrap.get(integrationFunctionError);
  690.                     
  691.                     if(integrationFunctionError.isWrapBadRequest()) {
  692.                         if(isWrapped(IntegrationFunctionError.WRAP_400_INTERNAL_BAD_REQUEST)) {
  693.                             String pWrappedName = IntegrationFunctionError.WRAP_400_INTERNAL_BAD_REQUEST.name()+".genericDetails";
  694.                             p = getProperty(pWrappedName);
  695.                         }
  696.                     }
  697.                     else if(integrationFunctionError.isWrapBadResponse(integrationError)) {
  698.                         if(isWrapped(IntegrationFunctionError.WRAP_502_BAD_RESPONSE)) {
  699.                             String pWrappedName = IntegrationFunctionError.WRAP_502_BAD_RESPONSE.name()+".genericDetails";
  700.                             p = getProperty(pWrappedName);
  701.                         }
  702.                     }
  703.                     else if(integrationFunctionError.isWrapInternalResponseError(integrationError)) {
  704.                         if(isWrapped(IntegrationFunctionError.WRAP_502_INTERNAL_RESPONSE_ERROR)) {
  705.                             String pWrappedName = IntegrationFunctionError.WRAP_502_INTERNAL_RESPONSE_ERROR.name()+".genericDetails";
  706.                             p = getProperty(pWrappedName);
  707.                         }
  708.                     }
  709.                     else if(integrationFunctionError.isWrapInternalError()) {
  710.                         if(isWrapped(IntegrationFunctionError.WRAP_503_INTERNAL_ERROR)) {
  711.                             String pWrappedName = IntegrationFunctionError.WRAP_503_INTERNAL_ERROR.name()+".genericDetails";
  712.                             p = getProperty(pWrappedName);
  713.                         }
  714.                     }       
  715.                     
  716.                     this.mapGenericDetails.put(integrationFunctionError, p);
  717.                     this.mapGenericDetails_noWrap.put(integrationFunctionError, p_noWrap);
  718.                 }catch(Exception e){
  719.                     throw new ProtocolException("Errore durante la gestione del codice ["+integrationFunctionError.name()+"]: "+e.getMessage(),e);
  720.                 }
  721.             }
  722.         }
  723.     }
  724.     
  725.     
  726.     private ConcurrentHashMap<IntegrationFunctionError,Boolean> mapIsGenericDetails= null;
  727.     private ConcurrentHashMap<IntegrationFunctionError,Boolean> mapIsGenericDetails_noWrap= null;
  728.     public Boolean isForceGenericDetails(IntegrationFunctionError functionError) throws ProtocolException {
  729.         if(this.mapIsGenericDetails==null){
  730.             this.initMapIsGenericDetails();
  731.         }
  732.         return this.mapIsGenericDetails.get(functionError);
  733.     }
  734.     public Boolean isForceGenericDetails_noWrap(IntegrationFunctionError functionError) throws ProtocolException {
  735.         if(this.mapIsGenericDetails_noWrap==null){
  736.             this.initMapIsGenericDetails();
  737.         }
  738.         return this.mapIsGenericDetails_noWrap.get(functionError);
  739.     }
  740.     private synchronized void initMapIsGenericDetails() throws ProtocolException {
  741.         if(this.mapIsGenericDetails==null){
  742.             this.mapIsGenericDetails = new ConcurrentHashMap<IntegrationFunctionError, Boolean>();
  743.             this.mapIsGenericDetails_noWrap = new ConcurrentHashMap<IntegrationFunctionError, Boolean>();
  744.             IntegrationFunctionError [] lista = IntegrationFunctionError.values();
  745.             for (IntegrationFunctionError integrationFunctionError : lista) {
  746.                 String pName = integrationFunctionError.name()+".forceGenericDetails";
  747.                 try{
  748.                     Boolean p = getBooleanProperty(pName);
  749.                     Boolean p_noWrap = p;
  750.                     
  751.                     IntegrationError integrationError = this.mapIntegrationError_noWrap.get(integrationFunctionError);
  752.                     
  753.                     if(integrationFunctionError.isWrapBadRequest()) {
  754.                         if(isWrapped(IntegrationFunctionError.WRAP_400_INTERNAL_BAD_REQUEST)) {
  755.                             String pWrappedName = IntegrationFunctionError.WRAP_400_INTERNAL_BAD_REQUEST.name()+".forceGenericDetails";
  756.                             p = getBooleanProperty(pWrappedName);
  757.                         }
  758.                     }
  759.                     else if(integrationFunctionError.isWrapBadResponse(integrationError)) {
  760.                         if(isWrapped(IntegrationFunctionError.WRAP_502_BAD_RESPONSE)) {
  761.                             String pWrappedName = IntegrationFunctionError.WRAP_502_BAD_RESPONSE.name()+".forceGenericDetails";
  762.                             p = getBooleanProperty(pWrappedName);
  763.                         }
  764.                     }
  765.                     else if(integrationFunctionError.isWrapInternalResponseError(integrationError)) {
  766.                         if(isWrapped(IntegrationFunctionError.WRAP_502_INTERNAL_RESPONSE_ERROR)) {
  767.                             String pWrappedName = IntegrationFunctionError.WRAP_502_INTERNAL_RESPONSE_ERROR.name()+".forceGenericDetails";
  768.                             p = getBooleanProperty(pWrappedName);
  769.                         }
  770.                     }
  771.                     else if(integrationFunctionError.isWrapInternalError()) {
  772.                         if(isWrapped(IntegrationFunctionError.WRAP_503_INTERNAL_ERROR)) {
  773.                             String pWrappedName = IntegrationFunctionError.WRAP_503_INTERNAL_ERROR.name()+".forceGenericDetails";
  774.                             p = getBooleanProperty(pWrappedName);
  775.                         }
  776.                     }   
  777.                     
  778.                     this.mapIsGenericDetails.put(integrationFunctionError, p);
  779.                     this.mapIsGenericDetails_noWrap.put(integrationFunctionError, p_noWrap);
  780.                 }catch(Exception e){
  781.                     throw new ProtocolException("Errore durante la gestione del codice ["+integrationFunctionError.name()+"]: "+e.getMessage(),e);
  782.                 }
  783.             }
  784.         }
  785.     }

  787.     


  790.     
  791.     
  792.     /* ******* UTILITIES ********* */
  793.     
  794.     public String getProperty(String property) throws ProtocolException {
  795.         try{ 
  796.             String name = null;
  797.             name = this.reader.getValueConvertEnvProperties(property);
  798.             if(name==null)
  799.                 throw new Exception("proprieta non definita");
  800.             return name.trim();
  801.         }catch(java.lang.Exception e) {
  802.             String msg = "Riscontrato errore durante la lettura della proprieta' '"+property+"': "+e.getMessage();
  803.             this.log.error(msg,e);
  804.             throw new ProtocolException(msg,e);
  805.         }      
  806.     }
  807.     
  808.     public String getOptionalProperty(String property) throws ProtocolException {
  809.         try{ 
  810.             String name = null;
  811.             name = this.reader.getValueConvertEnvProperties(property);
  812.             if(name==null)
  813.                 return null;
  814.             return name.trim();
  815.         }catch(java.lang.Exception e) {
  816.             String msg = "Riscontrato errore durante la lettura della proprieta' '"+property+"': "+e.getMessage();
  817.             this.log.error(msg,e);
  818.             throw new ProtocolException(msg,e);
  819.         }      
  820.     }
  821.     
  822.     public Boolean getBooleanProperty(String property) throws ProtocolException {
  823.         try{ 
  824.             String name = null;
  825.             name = this.reader.getValueConvertEnvProperties(property);
  826.             if(name==null)
  827.                 throw new Exception("proprieta non definita");
  828.             return Boolean.parseBoolean(name.trim());
  829.         }catch(java.lang.Exception e) {
  830.             String msg = "Riscontrato errore durante la lettura della proprieta' '"+property+"': "+e.getMessage();
  831.             this.log.error(msg,e);
  832.             throw new ProtocolException(msg,e);
  833.         }      
  834.     }
  835.     
  836. }
Created with JaCoCo 0.8.8.202204050719