IntegrationErrorConfiguration.java

  1. /*
  2.  * GovWay - A customizable API Gateway 
  3.  * https://govway.org
  4.  * 
  5.  * Copyright (c) 2005-2025 Link.it srl (https://link.it). 
  6.  * 
  7.  * This program is free software: you can redistribute it and/or modify
  8.  * it under the terms of the GNU General Public License version 3, as published by
  9.  * the Free Software Foundation.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18.  *
  19.  */



  23. package org.openspcoop2.message.config;

  25. import java.util.List;

  27. import org.openspcoop2.message.constants.IntegrationErrorMessageType;
  28. import org.openspcoop2.message.constants.MessageType;
  29. import org.openspcoop2.message.constants.ServiceBinding;
  30. import org.openspcoop2.utils.transport.http.HttpConstants;
  31. import org.openspcoop2.utils.transport.http.HttpServletTransportRequestContext;

  33. /**
  34.  * IntegrationErrorConfiguration
  35.  *
  36.  *
  37.  * @author Poli Andrea (apoli@link.it)
  38.  * @author $Author$
  39.  * @version $Rev$, $Date$
  40.  */

  42. public class IntegrationErrorConfiguration implements java.io.Serializable {

  44.     /**
  45.      * serialVersionUID
  46.      */
  47.     private static final long serialVersionUID = 1L;

  49.     private IntegrationErrorMessageType errorType;
  50.     private IntegrationErrorMessageType defaultErrorType;
  51.     private ConfigurationRFC7807 rfc7807;
  52.     private IntegrationErrorReturnConfiguration errorReturnConfig;
  53.     private boolean useInternalFault; // in cooperazione
  54.         
  55.     public IntegrationErrorConfiguration(ConfigurationRFC7807 rfc7807, IntegrationErrorMessageType errorType, 
  56.             IntegrationErrorReturnConfiguration errorReturnConfig,  
  57.             boolean useInternalFault){
  58.         this.rfc7807 = rfc7807;
  59.         this.errorType = errorType;
  60.         this.errorReturnConfig = errorReturnConfig;
  61.         this.useInternalFault = useInternalFault;
  62.     }
  63.     
  64.     void setDefaultErrorType(IntegrationErrorMessageType defaultErrorType) {
  65.         this.defaultErrorType = defaultErrorType;
  66.     }

  68.     public ConfigurationRFC7807 getRfc7807() {
  69.         return this.rfc7807;
  70.     }
  71.     public IntegrationErrorReturnConfiguration getErrorReturnConfig() {
  72.         return this.errorReturnConfig;
  73.     }
  74.     public boolean isUseInternalFault() {
  75.         return this.useInternalFault;
  76.     }
  77.     
  78.     public MessageType getMessageType(HttpServletTransportRequestContext request, ServiceBinding serviceBinding, MessageType requestMsgType){
  79.         if(ServiceBinding.REST.equals(serviceBinding) && this.rfc7807!=null) {
  80.             if(this.rfc7807.isUseAcceptHeader() && request!=null && request.getHeaderValues(HttpConstants.ACCEPT)!=null && !request.getHeaderValues(HttpConstants.ACCEPT).isEmpty()) {
  81.                 List<String> values = request.getHeaderValues(HttpConstants.ACCEPT);
  82.                 // https://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html
  83.                 /*
  84.                  * Example from rfc:
  85.                     Accept: text/plain; q=0.5, text/html, text/x-dvi; q=0.8, text/x-c
  86.                     Verbally, this would be interpreted as "text/html and text/x-c are the preferred media types, but if they do not exist, then send the text/x-dvi entity, and if that does not exist, send the text/plain entity."
  87.                  **/
  88.                 boolean readQparameter = true;
  89.                 MessageType mt = readMessageTypeFromAccept(values, !readQparameter); // prima priorità a quelli senza q parameter
  90.                 if(mt!=null) {
  91.                     return mt;
  92.                 }
  93.                 
  94.                 // altrimenti esamino quelli con q parameter
  95.                 mt = readMessageTypeFromAccept(values, readQparameter); // prima priorità a quelli senza q parameter
  96.                 if(mt!=null) {
  97.                     return mt;
  98.                 }
  99.             }
  100.         }
  101.         
  102.         switch (this.errorType) {
  103.         case SOAP_AS_REQUEST:
  104.             if(MessageType.SOAP_11.equals(requestMsgType) || MessageType.SOAP_12.equals(requestMsgType) )
  105.                 return requestMsgType;          
  106.             return getDefaultMessageType(requestMsgType);
  107.         case SOAP_11:
  108.             return MessageType.SOAP_11;
  109.         case SOAP_12:
  110.             return MessageType.SOAP_12;
  111.         case XML:
  112.             return MessageType.XML;
  113.         case JSON:
  114.             return MessageType.JSON;
  115.         case SAME_AS_REQUEST:
  116.             if(MessageType.SOAP_11.equals(requestMsgType) || MessageType.SOAP_12.equals(requestMsgType) )
  117.                 return requestMsgType;
  118.             if(MessageType.XML.equals(requestMsgType) || MessageType.JSON.equals(requestMsgType) )
  119.                 return requestMsgType;
  120.             return getDefaultMessageType(requestMsgType);
  121.         default:
  122.             return MessageType.BINARY; // content is null
  123.         }
  124.     }
  125.     public MessageType getDefaultMessageType(MessageType requestMsgType){
  126.         switch (this.defaultErrorType) {
  127.         case SOAP_11:
  128.             return MessageType.SOAP_11;
  129.         case SOAP_12:
  130.             return MessageType.SOAP_12;
  131.         case XML:
  132.             return MessageType.XML;
  133.         case JSON:
  134.             return MessageType.JSON;
  135.         default:
  136.             return MessageType.BINARY; // content is null
  137.         }
  138.     }
  139.     
  140.     private MessageType readMessageTypeFromAccept(List<String> values, boolean readQparameter) {
  141.         boolean asJson = false;
  142.         boolean asXml = false;
  143.         // https://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html
  144.         for (String value : values) {
  145.             String [] acceptHeaders = null;
  146.             if(value.contains(",")) {
  147.                 acceptHeaders = value.split(",");
  148.                 for (int i = 0; i < acceptHeaders.length; i++) {
  149.                     acceptHeaders[i] = acceptHeaders[i].trim();
  150.                 }
  151.             }
  152.             else {
  153.                 acceptHeaders = new String [] {value.trim()};
  154.             }
  155.             double asJsonParamterQ = 0;
  156.             double asXmlParamterQ = 0;
  157.             for (String hdr : acceptHeaders) {
  158.                 if(readQparameter) {
  159.                     if(hdr.contains(";")) {
  160.                         String [] tmp = hdr.split(";");
  161.                         if(tmp!=null && tmp.length==2) {
  162.                             String mediaType = tmp[0];
  163.                             String q = tmp[1];
  164.                             if(mediaType!=null && q!=null) {
  165.                                 q = q.trim();
  166.                                 mediaType = mediaType.trim();
  167.                                 if(q.contains("=")) {
  168.                                     String [] tmpQ = q.split("=");
  169.                                     if(tmpQ!=null && tmpQ.length==2) {
  170.                                         String qParam = tmpQ[0];
  171.                                         String qParamValue = tmpQ[1];
  172.                                         if(qParam!=null && "q".equalsIgnoreCase(qParam.trim()) && qParamValue!=null) {
  173.                                             double d = 0;
  174.                                             try {
  175.                                                 d = Double.valueOf(qParamValue.trim());
  176.                                                 if(d>0) {
  177.                                                     if(isJsonMediaType(mediaType)){
  178.                                                         if(d>asJsonParamterQ) {
  179.                                                             asJsonParamterQ = d;
  180.                                                             asJson = true;
  181.                                                         }
  182.                                                     }
  183.                                                     else if(isXmlMediaType(mediaType)){
  184.                                                         if(d>asXmlParamterQ) {
  185.                                                             asXmlParamterQ = d;
  186.                                                             asXml = true;
  187.                                                         }
  188.                                                     }                   
  189.                                                 }
  190.                                             }catch(Throwable t) {}
  191.                                         }
  192.                                     }
  193.                                 }
  194.                             }
  195.                         }
  196.                     }
  197.                 }
  198.                 else {
  199.                     if(isJsonMediaType(hdr)){
  200.                         asJson = true;
  201.                         break;
  202.                     }
  203.                     else if(isXmlMediaType(hdr)){
  204.                         asXml = true;
  205.                         break;
  206.                     }
  207.                 }
  208.             }
  209.             
  210.             if(asJson && asXml && readQparameter) {
  211.                 if(asJsonParamterQ>asXmlParamterQ) {
  212.                     return MessageType.JSON;
  213.                 }
  214.                 else {
  215.                     return MessageType.XML;
  216.                 }
  217.             }
  218.             
  219.             if(asJson) {
  220.                 return MessageType.JSON;
  221.             }
  222.             else if(asXml) {
  223.                 return MessageType.XML;
  224.             }
  225.         }
  226.         return null;
  227.     }
  228.     private boolean isJsonMediaType(String hdrValue) {
  229.         if(hdrValue.toLowerCase().endsWith("/x-json") || hdrValue.toLowerCase().endsWith("/json") || hdrValue.toLowerCase().endsWith("+json")){
  230.             return true;
  231.         }
  232.         return false;
  233.     }
  234.     private boolean isXmlMediaType(String hdrValue) {
  235.         if(hdrValue.toLowerCase().endsWith("/x-xml") || hdrValue.toLowerCase().endsWith("/xml") || hdrValue.toLowerCase().endsWith("+xml")){
  236.             return true;
  237.         }
  238.         return false;
  239.     }
  240. }




Created with JaCoCo 0.8.8.202204050719