TransportUtils.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.utils.transport;

  22. import java.net.URLDecoder;
  23. import java.util.ArrayList;
  24. import java.util.Collection;
  25. import java.util.Enumeration;
  26. import java.util.HashMap;
  27. import java.util.Iterator;
  28. import java.util.List;
  29. import java.util.Map;

  31. import javax.servlet.http.Cookie;
  32. import javax.servlet.http.HttpServletRequest;
  33. import javax.servlet.http.HttpServletResponse;

  35. import org.openspcoop2.utils.LoggerWrapperFactory;
  36. import org.openspcoop2.utils.UtilsRuntimeException;
  37. import org.openspcoop2.utils.resources.Charset;
  38. import org.slf4j.Logger;
  39. import org.springframework.web.util.UriUtils;

  41. /**
  42.  * TransportUtils
  43.  *
  44.  *
  45.  * @author Andrea Poli (apoli@link.it)
  46.  * @author $Author$
  47.  * @version $Rev$, $Date$
  48.  */
  49. public class TransportUtils {
  50.     
  51.     private TransportUtils() {}

  53.     public static final String LDAP_PREFIX = "ldap://";
  54.     public static final String HTTP_PREFIX = "http://";
  55.     public static final String HTTPS_PREFIX = "https://";
  56.     public static final String FILE_PREFIX = "file://";
  57.     public static boolean isRemoteResource(String r) {
  58.         return r!=null && 
  59.                 (r.trim().startsWith(LDAP_PREFIX) 
  60.                         ||
  61.                         r.trim().startsWith(HTTP_PREFIX) 
  62.                         ||
  63.                         r.trim().startsWith(HTTPS_PREFIX) 
  64.                         ||
  65.                         r.trim().startsWith(FILE_PREFIX) );
  66.     }
  67.     public static boolean isLdapResource(String r) {
  68.         return r!=null && 
  69.                 (r.trim().startsWith(LDAP_PREFIX) );
  70.     }
  71.     public static boolean isHttpResource(String r) {
  72.         return r!=null && 
  73.                 (r.trim().startsWith(HTTP_PREFIX) );
  74.     }
  75.     public static boolean isHttpsResource(String r) {
  76.         return r!=null && 
  77.                 (r.trim().startsWith(HTTPS_PREFIX) );
  78.     }
  79.     public static boolean isFileResource(String r) {
  80.         return r!=null && 
  81.                 (r.trim().startsWith(FILE_PREFIX) );
  82.     }
  83.     
  84.     /* Gestione CaseInsensitive per Properties */

  86.     public static boolean containsKey(Map<String, List<String>> p, String name) {
  87.         return hasKeyEngine(p, name);
  88.     }
  89.     @Deprecated
  90.     public static boolean hasKey(Map<String, String> p, String name) {
  91.         return hasKeyEngine(p, name);
  92.     }
  93.     private static boolean hasKeyEngine(Map<String, ?> p, String name) {
  94.         
  95.         // rfc7230#page-22: Each header field consists of a case-insensitive field name followed by a colon (":")
  96.         
  97.         if(p==null || p.isEmpty()) {
  98.             return false;
  99.         }
  100.         if(name==null) {
  101.             return false;
  102.         }
  103.         if(p.containsKey(name)) {
  104.             return true;
  105.         }
  106.         String lowerName = name.toLowerCase();
  107.         if(p.containsKey(lowerName)) {
  108.             return true;
  109.         }
  110.         if(p.containsKey(name.toUpperCase())) {
  111.             return true;
  112.         }
  113.         Iterator<String> keys = p.keySet().iterator();
  114.         while (keys.hasNext()) {
  115.             String key = keys.next();
  116.             String keyCaseInsensitive = key.toLowerCase();
  117.             if(keyCaseInsensitive.equals( lowerName )) {
  118.                 return true;
  119.             }
  120.         }
  121.         return false;
  122.         
  123.     }
  124.     
  125.     // Usare i metodi sottostanti come getRawObject e getObjectAsString
  126.     @Deprecated
  127.     public static String get(Map<String, String> p, String name) {
  128.         Object o = propertiesEngine(p, name, true);
  129.         return (o instanceof String) ? ((String)o) : null;
  130.     }
  131.     @Deprecated
  132.     public static Object remove(Map<String, String> p, String name) {
  133.         return propertiesEngine(p, name, false);
  134.     }
  135.     private static <T> T propertiesEngine(Map<String, T> p, String name, boolean get) {
  136.         
  137.         // rfc7230#page-22: Each header field consists of a case-insensitive field name followed by a colon (":")
  138.         
  139.         if(p==null || p.isEmpty()) {
  140.             return null;
  141.         }
  142.         if(name==null) {
  143.             return null;
  144.         }
  145.         T value = get ? p.get(name) : p.remove(name);
  146.         String lowerName = null;
  147.         if(value==null){
  148.             lowerName = name.toLowerCase();
  149.             value = get ? p.get( lowerName ) : p.remove( lowerName );
  150.         }
  151.         if(value==null){
  152.             value = get ? p.get(name.toUpperCase()) : p.remove(name.toUpperCase()); 
  153.         }
  154.         if(value==null){
  155.             List<String> keysFound = new ArrayList<>();
  156.             Iterator<String> keys = p.keySet().iterator();
  157.             while (keys.hasNext()) {
  158.                 String key = keys.next();
  159.                 String keyCaseInsensitive = key.toLowerCase();
  160.                 if ( lowerName == null )
  161.                     lowerName = name.toLowerCase();
  162.                 String nameCaseInsensitive = lowerName;
  163.                 if(keyCaseInsensitive.equals(nameCaseInsensitive)) {
  164.                     keysFound.add(key);
  165.                 }
  166.             }
  167.             if(!keysFound.isEmpty()) {
  168.                 for (String keyFound : keysFound) {
  169.                     T v = get? p.get(keyFound) : p.remove(keyFound);
  170.                     if(value==null) {
  171.                         value=v;
  172.                     }
  173.                 }
  174.             }
  175.         }
  176.         return value;
  177.         
  178.     }
  179.     
  180.     
  181.     
  182.     /* Gestione CaseInsensitive per Map */
  183.     
  184.     public static boolean mapHasKey(Map<String, Object> map, String name) {
  185.         
  186.         // rfc7230#page-22: Each header field consists of a case-insensitive field name followed by a colon (":")
  187.         
  188.         if(map==null || map.isEmpty()) {
  189.             return false;
  190.         }
  191.         if(name==null) {
  192.             return false;
  193.         }
  194.         if(map.containsKey(name)) {
  195.             return true;
  196.         }
  197.         String lowerName = name.toLowerCase();
  198.         if(map.containsKey( lowerName )) {
  199.             return true;
  200.         }
  201.         if(map.containsKey(name.toUpperCase())) {
  202.             return true;
  203.         }
  204.         Iterator<String> keys = map.keySet().iterator();
  205.         while (keys.hasNext()) {
  206.             String key = keys.next();
  207.             if(key!=null) {
  208.                 String keyCaseInsensitive = key.toLowerCase();
  209.                 if(keyCaseInsensitive.equals( lowerName )) {
  210.                     return true;
  211.                 }
  212.             }
  213.         }
  214.         return false;
  215.         
  216.     }
  217.     public static String getObjectAsString(Map<String, ?> map, String name) {
  218.         return (String) mapEngine(map, name, true, true);
  219.     }
  220.     public static String removeObjectAsString(Map<String, ?> map, String name) {
  221.         return (String) mapEngine(map, name, false, true);
  222.     }
  223.     @SuppressWarnings("unchecked")
  224.     public static <T> T getRawObject(Map<String, T> map, String name) {
  225.         return (T) mapEngine(map, name, true, false);
  226.     }
  227.     @SuppressWarnings("unchecked")
  228.     public static <T> T removeRawObject(Map<String, T> map, String name) {
  229.         return (T) mapEngine(map, name, false, false);
  230.     }
  231.     public static void removeObject(Map<String, ?> map, String name) {
  232.         mapEngine(map, name, false, false);
  233.     }
  234.     private static Object mapEngine(Map<String, ?> map, String name, boolean get, boolean returnAsString) {
  235.         
  236.         // rfc7230#page-22: Each header field consists of a case-insensitive field name followed by a colon (":")
  237.         
  238.         if(map==null || map.isEmpty()) {
  239.             return null;
  240.         }
  241.         if(name==null) {
  242.             return null;
  243.         }
  244.         String lowerName = null;
  245.         Object value = get? map.get(name) : map.remove(name);
  246.         if(value==null){
  247.             lowerName = name.toLowerCase();
  248.             value = get? map.get( lowerName ) : map.remove( lowerName );
  249.         }
  250.         if(value==null){
  251.             value = get? map.get(name.toUpperCase()) : map.remove(name.toUpperCase());
  252.         }
  253.         if(value==null){
  254.             List<String> keysFound = new ArrayList<>();
  255.             Iterator<String> keys = map.keySet().iterator();
  256.             while (keys.hasNext()) {
  257.                 String key = keys.next();
  258.                 if(key!=null) {
  259.                     String keyCaseInsensitive = key.toLowerCase();
  260.                     if ( lowerName == null )
  261.                         lowerName = name.toLowerCase();
  262.                     String nameCaseInsensitive = lowerName;
  263.                     if(keyCaseInsensitive.equals(nameCaseInsensitive)) {
  264.                         keysFound.add(key);
  265.                     }
  266.                 }
  267.             }
  268.             if(!keysFound.isEmpty()) {
  269.                 for (String keyFound : keysFound) {
  270.                     Object v = get? map.get(keyFound) : map.remove(keyFound);
  271.                     if(value==null) {
  272.                         value=v;
  273.                     }
  274.                 }
  275.             }
  276.         }
  277.         if(value==null) {
  278.             return null;
  279.         }
  280.         if(!returnAsString) {
  281.             return value; 
  282.         }
  283.         else {
  284.             if(value instanceof String) {
  285.                 return value;
  286.             }
  287.             else if(value instanceof List<?>) {
  288.                 List<?> l = (List<?>) value;
  289.                 return convertToSingleValue(l);
  290.             }
  291.             else {
  292.                 return value.toString();
  293.             }
  294.         }
  295.         
  296.     }
  297.     
  298.     
  299.     
  300.     /* HttpServlet */
  301.     
  302.     @Deprecated
  303.     public static String getParameter(HttpServletRequest request, String name) {
  304.         return getParameterFirstValue(request, name);
  305.     }
  306.     public static String getParameterFirstValue(HttpServletRequest request, String name) {
  307.         List<String> l = getParameterValues(request, name);
  308.         if(l!=null) {
  309.             return l.get(0);
  310.         }
  311.         return null;
  312.     }
  313.     public static List<String> getParameterValues(HttpServletRequest request, String name) {
  314.         // rfc7230#page-22: Each header field consists of a case-insensitive field name followed by a colon (":")
  315.         
  316.         List<String> lNullReturn = null;
  317.         
  318.         if(request==null) {
  319.             return lNullReturn;
  320.         }
  321.         if(name==null) {
  322.             return lNullReturn;
  323.         }
  324.         String lowerName = null;
  325.         String exactKeyName = null;
  326.         Enumeration<String> keys = request.getParameterNames();
  327.         if(keys!=null) {
  328.             while (keys.hasMoreElements()) {
  329.                 String key = keys.nextElement();
  330.                 String keyCaseInsensitive = key.toLowerCase();
  331.                 if ( lowerName == null )
  332.                     lowerName = name.toLowerCase();
  333.                 String nameCaseInsensitive = lowerName;
  334.                 if(keyCaseInsensitive.equals(nameCaseInsensitive)) {
  335.                     exactKeyName = key;
  336.                     break;
  337.                 }
  338.             }
  339.         }
  340.         if(exactKeyName==null) {
  341.             return lNullReturn;
  342.         }
  343.         
  344.         String [] s = request.getParameterValues(exactKeyName);
  345.         List<String> values = new ArrayList<>();
  346.         if(s!=null && s.length>0) {
  347.             for (int i = 0; i < s.length; i++) {
  348.                 String value = s[i];
  349.                 values.add(value);
  350.                 /**System.out("Parameter ["+nomeProperty+"] valore-"+i+" ["+value+"]");*/
  351.             }
  352.         }
  353.         else {
  354.             /**System.out("Parameter ["+nomeProperty+"] valore ["+req.getParameter(nomeProperty)+"]");*/
  355.             values.add(request.getParameter(exactKeyName));
  356.         }
  357.         
  358.         return values;
  359.         
  360.     }
  361.     
  362.     @Deprecated
  363.     public static String getHeader(HttpServletRequest request, String name) {
  364.         return getHeaderFirstValue(request, name);
  365.     }
  366.     public static String getHeaderFirstValue(HttpServletRequest request, String name) {
  367.         List<String> l = getHeaderValues(request, name);
  368.         if(l!=null) {
  369.             return l.get(0);
  370.         }
  371.         return null;
  372.     }
  373.     public static List<String> getHeaderValues(HttpServletRequest request, String name) {
  374.         
  375.         // rfc7230#page-22: Each header field consists of a case-insensitive field name followed by a colon (":")
  376.         
  377.         List<String> lNullReturn = null;
  378.         
  379.         if(request==null) {
  380.             return lNullReturn;
  381.         }
  382.         if(name==null) {
  383.             return lNullReturn;
  384.         }
  385.         String lowerName = null;
  386.         String exactKeyName = null;
  387.         Enumeration<String> keys = request.getHeaderNames();
  388.         if(keys!=null) {
  389.             while (keys.hasMoreElements()) {
  390.                 String key = keys.nextElement();
  391.                 String keyCaseInsensitive = key.toLowerCase();
  392.                 if ( lowerName == null )
  393.                     lowerName = name.toLowerCase();
  394.                 String nameCaseInsensitive = lowerName;
  395.                 if(keyCaseInsensitive.equals(nameCaseInsensitive)) {
  396.                     exactKeyName = key;
  397.                     break;
  398.                 }
  399.             }
  400.         }
  401.         if(exactKeyName==null) {
  402.             return lNullReturn;
  403.         }
  404.         
  405.         Enumeration<String> enValues = request.getHeaders(exactKeyName);
  406.         List<String> values = new ArrayList<>();
  407.         if(enValues!=null) {
  408.             @SuppressWarnings("unused")
  409.             int i = 0;
  410.             while (enValues.hasMoreElements()) {
  411.                 String value = enValues.nextElement();
  412.                 values.add(value);
  413.                 /**System.out("Header ["+nomeHeader+"] valore-"+i+" ["+value+"]");*/
  414.                 i++;
  415.             }
  416.         }
  417.         if(values.isEmpty()) {
  418.             /**System.out("Header ["+nomeHeader+"] valore ["+req.getHeader(nomeHeader)+"]");*/
  419.             values.add(request.getHeader(exactKeyName));
  420.         }
  421.         
  422.         return values;
  423.         
  424.     }
  425.     
  426.     @Deprecated
  427.     public static String getHeader(HttpServletResponse response, String name) {
  428.         return getHeaderFirstValue(response, name);
  429.     }
  430.     public static String getHeaderFirstValue(HttpServletResponse response, String name) {
  431.         List<String> l = getHeaderValues(response, name);
  432.         if(l!=null) {
  433.             return l.get(0);
  434.         }
  435.         return null;
  436.     }
  437.     public static List<String> getHeaderValues(HttpServletResponse response, String name) {
  438.                 
  439.         // rfc7230#page-22: Each header field consists of a case-insensitive field name followed by a colon (":")
  440.         
  441.         List<String> lNullReturn = null;
  442.         
  443.         if(response==null) {
  444.             return lNullReturn;
  445.         }
  446.         if(name==null) {
  447.             return lNullReturn;
  448.         }
  449.         String lowerName = null;
  450.         String exactKeyName = null;
  451.         if(response.getHeaderNames()!=null && !response.getHeaderNames().isEmpty()) {
  452.             Iterator<String> keys = response.getHeaderNames().iterator();
  453.             if(keys!=null) {
  454.                 while (keys.hasNext()) {
  455.                     String key = keys.next();
  456.                     String keyCaseInsensitive = key.toLowerCase();
  457.                     if ( lowerName == null )
  458.                         lowerName = name.toLowerCase();
  459.                     String nameCaseInsensitive = lowerName;
  460.                     if(keyCaseInsensitive.equals(nameCaseInsensitive)) {
  461.                         exactKeyName = key;
  462.                     }
  463.                 }
  464.             }
  465.         }
  466.         if(exactKeyName==null) {
  467.             return lNullReturn;
  468.         }
  469.         
  470.         Collection<String> enValues = response.getHeaders(exactKeyName);
  471.         List<String> values = new ArrayList<>();
  472.         if(enValues!=null && !enValues.isEmpty()) {
  473.             @SuppressWarnings("unused")
  474.             int i = 0;
  475.             for (String value : enValues) {
  476.                 values.add(value);
  477.                 /**System.out("Header ["+nomeHeader+"] valore-"+i+" ["+value+"]");*/
  478.                 i++;
  479.             }
  480.         }
  481.         if(values.isEmpty()) {
  482.             /**System.out("Header ["+nomeHeader+"] valore ["+req.getHeader(nomeHeader)+"]");*/
  483.             values.add(response.getHeader(exactKeyName));
  484.         }
  485.         
  486.         return values;
  487.         
  488.     }
  489.     
  490.     public static String getCookie(HttpServletRequest request, String name) {
  491.         
  492.         // rfc7230#page-22: Each header field consists of a case-insensitive field name followed by a colon (":")
  493.         
  494.         if(request==null) {
  495.             return null;
  496.         }
  497.         if(name==null) {
  498.             return null;
  499.         }
  500.         Cookie[] c = request.getCookies();
  501.         if(c==null || c.length<=0) {
  502.             return null;
  503.         }
  504.         for (Cookie cookie : c) {
  505.             if(cookie!=null && cookie.getName()!=null) {
  506.                 if(cookie.getName().equalsIgnoreCase(name)) {
  507.                     try {
  508.                         return URLDecoder.decode(cookie.getValue(), Charset.UTF_8.getValue());
  509.                     }catch(Exception e) {
  510.                         throw new UtilsRuntimeException(e.getMessage(),e);
  511.                     }
  512.                 }
  513.             }
  514.         }
  515.         return null;

  517.     }
  518.     
  519.     
  520.     
  521.     
  522.     
  523.     /* Gestione URL */
  524.     
  525.     @Deprecated
  526.     public static String buildLocationWithURLBasedParameter(Map<String, String> propertiesURLBased, String location){
  527.         return buildLocationWithURLBasedParameter(propertiesURLBased, location, false, LoggerWrapperFactory.getLogger(TransportUtils.class));
  528.     }
  529.     @Deprecated
  530.     public static String buildLocationWithURLBasedParameter(Map<String, String> propertiesURLBased, String location, Logger log){
  531.         return buildLocationWithURLBasedParameter(propertiesURLBased, location, false, log);
  532.     }
  533.     @Deprecated
  534.     public static String buildLocationWithURLBasedParameter(Map<String, String> propertiesURLBased, String location, boolean encodeLocation){
  535.         return buildLocationWithURLBasedParameter(propertiesURLBased, location, encodeLocation, LoggerWrapperFactory.getLogger(TransportUtils.class));
  536.     }
  537.     @Deprecated
  538.     public static String buildLocationWithURLBasedParameter(Map<String, String> propertiesURLBased, String location, boolean encodeLocation, Logger log){
  539.         Map<String, List<String>> parameters = convertToMapListValues(propertiesURLBased);
  540.         return buildUrlWithParameters(parameters, location, encodeLocation, log);
  541.     }
  542.     
  543.     public static String buildUrlWithParameters(Map<String, List<String>> parameters, String location){
  544.         return buildUrlWithParameters(parameters, location, false, LoggerWrapperFactory.getLogger(TransportUtils.class));
  545.     }
  546.     public static String buildUrlWithParameters(Map<String, List<String>> parameters, String location, Logger log){
  547.         return buildUrlWithParameters(parameters, location, false, log);
  548.     }
  549.     public static String buildUrlWithParameters(Map<String, List<String>> parameters, String location, boolean encodeLocation){
  550.         return buildUrlWithParameters(parameters, location, encodeLocation, LoggerWrapperFactory.getLogger(TransportUtils.class));
  551.     }
  552.     public static String buildUrlWithParameters(Map<String, List<String>> parameters, String location, boolean encodeLocation, Logger log){
  553.         String locationEncoded = location;
  554.         if(encodeLocation) {
  555.             locationEncoded = UriUtils.encodeQuery(location,Charset.UTF_8.getValue());
  556.         }
  557.         
  558.         if(parameters != null && parameters.size()>0){
  559.             StringBuilder urlBuilder = new StringBuilder(locationEncoded);
  560.             Iterator<String> keys = parameters.keySet().iterator();
  561.             while (keys.hasNext()) {
  562.                 
  563.                 String key = keys.next();
  564.                 List<String> list = parameters.get(key);
  565.                 if(list!=null && !list.isEmpty()) {
  566.                 
  567.                     for (String value : list) {
  568.                         
  569.                         if(!urlBuilder.toString().contains("?"))
  570.                             urlBuilder.append("?");
  571.                         else
  572.                             urlBuilder.append("&");
  573.                         
  574.                         try{
  575.                             key = urlEncodeParam(key,Charset.UTF_8.getValue());
  576.                         }catch(Exception e){
  577.                             if(log!=null) {
  578.                                 log.error("URLEncode key["+key+"] error: "+e.getMessage(),e);
  579.                             }
  580.                             else {
  581.                                 LoggerWrapperFactory.getLogger(TransportUtils.class).error("URLEncode key["+key+"] error: "+e.getMessage(),e);
  582.                             }
  583.                         }
  584.                         
  585.                         try{
  586.                             value = urlEncodeParam(value,Charset.UTF_8.getValue());
  587.                         }catch(Exception e){
  588.                             if(log!=null) {
  589.                                 log.error("URLEncode value:["+value+"] error: "+e.getMessage(),e);
  590.                             }
  591.                             else {
  592.                                 LoggerWrapperFactory.getLogger(TransportUtils.class).error("URLEncode value:["+value+"] error: "+e.getMessage(),e);
  593.                             }
  594.                         }
  595.                         
  596.                         String keyValue = key+"="+value;
  597.                         urlBuilder.append(keyValue);
  598.                         
  599.                     }
  600.                     
  601.                 }
  602.             }
  603.             return urlBuilder.toString();
  604.         }
  605.         else{
  606.             return locationEncoded;
  607.         }
  608.     }

  610.     public static String limitLocation255Character(String location){
  611.         if(location.length()>255){
  612.             return location.substring(0,251)+" ...";
  613.         }
  614.         else{
  615.             return location;
  616.         }
  617.     }
  618.     
  619.     
  620.     public static String urlEncodeParam(String value, String charset) {
  621.         
  622.         // Note that Java’s URLEncoder class encodes space character(" ") into a + sign. 
  623.         // This is contrary to other languages like Javascript that encode space character into %20.
  624.         
  625.         /*
  626.          *  URLEncoder is not for encoding URLs, but for encoding parameter names and values for use in GET-style URLs or POST forms. 
  627.          *  That is, for transforming plain text into the application/x-www-form-urlencoded MIME format as described in the HTML specification. 
  628.          **/
  629.                 
  630.         /**return java.net.URLEncoder.encode(value,"UTF8");*/
  631.         
  632.         // fix
  633.         String p = UriUtils.encodeQueryParam(value, charset);
  634.         int index = 0;
  635.         while(p.contains("+") && index<1000) {
  636.             p = p.replace("+", "%2B");
  637.             index++;
  638.         }
  639.         return p;
  640.     }
  641.     
  642.     public static String urlEncodePath(String value, String charset) {
  643.         return UriUtils.encode(value, charset);
  644.     }
  645.     
  646.     
  647.     /* ************** UTILITIES *************/
  648.     
  649.     public static String convertToSingleValue(List<?> l) {
  650.         if(l!=null && !l.isEmpty()) {
  651.             StringBuilder sb = new StringBuilder();
  652.             for (Object value : l) {
  653.                 if(value==null) {
  654.                     continue;
  655.                 }
  656.                 if(sb.length()>0) {
  657.                     sb.append(",");
  658.                 }
  659.                 sb.append(value);
  660.             }
  661.             if(sb.length()>0) {
  662.                 return sb.toString();
  663.             }
  664.             else {
  665.                 return null;
  666.             }
  667.         }
  668.         return null;
  669.     }
  670.     
  671.     public static Map<String, List<String>> convertToMapListValues(Map<String, String> mapSingleValue) {
  672.         Map<String, List<String>> mapMultipleValues = null;
  673.         if(mapSingleValue!=null && !mapSingleValue.isEmpty()) {
  674.             mapMultipleValues = new HashMap<>();
  675.             Iterator<String> keys = mapSingleValue.keySet().iterator();
  676.             while (keys.hasNext()) {
  677.                 String key = keys.next();
  678.                 String value = mapSingleValue.get(key);
  679.                 List<String> l = new ArrayList<>();
  680.                 l.add(value);
  681.                 mapMultipleValues.put(key, l);
  682.             }
  683.         }
  684.         return mapMultipleValues;
  685.     }
  686.     
  687.     public static Map<String, String> convertToMapSingleValue(Map<String, List<String>> mapMultipleValues) {
  688.         Map<String, String> mapSingleValue = null;
  689.         if(mapMultipleValues!=null && !mapMultipleValues.isEmpty()) {
  690.             mapSingleValue = new HashMap<>();
  691.             Iterator<String> keys = mapMultipleValues.keySet().iterator();
  692.             while (keys.hasNext()) {
  693.                 String key = keys.next();
  694.                 List<String> values = mapMultipleValues.get(key);
  695.                 String v = convertToSingleValue(values);
  696.                 if(v!=null) {
  697.                     mapSingleValue.put(key, v);
  698.                 }
  699.             }
  700.         }
  701.         return mapSingleValue;
  702.     }
  703.     
  704.     public static void addHeader(Map<String, List<String>> headers, String name, String value) {
  705.         put(headers, name, value, true);
  706.     }
  707.     public static void setHeader(Map<String, List<String>> headers, String name, String value) {
  708.         put(headers, name, value, false);
  709.     }
  710.     
  711.     public static void addParameter(Map<String, List<String>> parameters, String name, String value) {
  712.         put(parameters, name, value, true);
  713.     }
  714.     public static void setParameter(Map<String, List<String>> parameters, String name, String value) {
  715.         put(parameters, name, value, false);
  716.     }
  717.     
  718.     public static void put(Map<String, List<String>> map, String name, String value, boolean add) {
  719.         
  720.         if(value==null) {
  721.             return;
  722.         }
  723.         
  724.         List<String> l = map.get(name);
  725.         if(add) {
  726.             if(l==null) {
  727.                 l = new ArrayList<>();
  728.                 map.put(name, l);
  729.             }
  730.         }
  731.         else {
  732.             if(l==null) {
  733.                 l = new ArrayList<>();
  734.                 map.put(name, l);
  735.             }
  736.             else {
  737.                 l.clear();
  738.             }
  739.         }
  740.         l.add(value);
  741.     }
  742.     
  743.     
  744.     
  745.     public static List<String> getValues(Map<String, List<String>> map, String key) {
  746.         List<String> lReturn = null;
  747.         if(map!=null && !map.isEmpty()) {
  748.             List<String> l = getRawObject(map, key); 
  749.             if(l!=null && !l.isEmpty()) {
  750.                 return l;
  751.             }
  752.         }
  753.         return lReturn;
  754.     }
  755.     
  756.     public static String getFirstValue(Map<String, List<String>> map, String key) {
  757.         if(map!=null && !map.isEmpty()) {
  758.             List<String> l = getRawObject(map, key); 
  759.             if(l!=null && !l.isEmpty()) {
  760.                 return l.get(0);
  761.             }
  762.         }
  763.         return null;
  764.     }
  765.     public static String getFirstValue(List<String> list) {
  766.         if(list!=null && !list.isEmpty()) {
  767.             return list.get(0);
  768.         }
  769.         return null;
  770.     }
  771. }
Created with JaCoCo 0.8.8.202204050719