Parameters.java

Go to the documentation of this file.

/*
 * Turró i Cutiller Foundation. License notice.
 * Copyright (C) 2023 Lluis Turró Cutiller <http://www.turro.org/>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
package org.turro.action;
 
import java.net.URLDecoder;
import java.net.URLEncoder;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.util.Base64;
import java.util.HashMap;
import java.util.Map;
import org.turro.collections.KeyValueMap;
import org.turro.collections.parser.ParserException;
import org.turro.log.WebLoggers;
import org.turro.string.Strings;
import org.turro.util.Converter;
 
public class Parameters {
 
  public String get(String key) {
    return parameters.get(key);
  }
  
  public <T> T get(String key, Class<T> javaClass) {
    return Converter.STANDARD.convert(parameters.get(key), javaClass);
  }
  
  public Parameters add(String key, Object value) {
    parameters.put(key, Converter.STANDARD.convert(value, String.class));
    return this;
  }
  
  public Parameters url(String url) {
    this.url = url;
    return this;
  }
  
  public String raw() {
    return raw("&");
  }
  
  public String raw(String separator) {
    StringBuilder sb = new StringBuilder();
    if(!Strings.isBlank(url)) {
      sb.append(url).append("?");
    }
    for(Map.Entry<String, String> entry : parameters.entrySet()) {
      if(!sb.isEmpty()) sb.append(separator);
      sb.append(entry.getKey()).append("=").append(entry.getValue());
    }
    return sb.toString();
  }
  
  public String plain() {
    return plain("&");
  }
  
  public String plain(String separator) {
    StringBuilder sb = new StringBuilder();
    if(!Strings.isBlank(url)) {
      sb.append(url).append("?");
    }
    for(Map.Entry<String, String> entry : parameters.entrySet()) {
      if(!sb.isEmpty()) sb.append(separator);
      sb.append(entry.getKey()).append("=").append(URLEncoder.encode(entry.getValue(), charset));
    }
    return sb.toString();
  }
  
  public String encoded() {
    StringBuilder sb = new StringBuilder();
    if(!Strings.isBlank(url)) {
      sb.append(url).append("?");
    }
    return sb.append(ENCODED).append("=")
            .append(Base64.getUrlEncoder().encodeToString(raw(";").getBytes(charset)))
            .toString();
  }
  
  public KeyValueMap asMap() {
    return new KeyValueMap(parameters);
  }
  
  /* Utils */
  
  private static String decode(String value) {
    return new String(Base64.getUrlDecoder().decode(value), charset);
  }
  
  private void addAll(KeyValueMap kvm) {
    parameters.putAll(kvm);
  }
  
  /* Factory */
 
  public static Parameters instance() {
    return new Parameters();
  }
  
  public static Parameters copy(Parameters pars) {
    Parameters instance = instance();
    instance.parameters.putAll(pars.parameters);
    return instance;
  }
  
  public static Parameters path(String path) {
    return instance().url(path);
  }
  
  public static Parameters from(Map<String, String[]> parameterMap) {
    Parameters instance = instance();
    if(parameterMap != null) {
      parameterMap.keySet().forEach((key) -> {
        if(ENCODED.equals(key)) {
          try {
            KeyValueMap kvm = new KeyValueMap(decode(parameterMap.get(key)[0]));
            if(kvm != null) instance.addAll(kvm);
          } catch (ParserException ex) {
            WebLoggers.info(Parameters.class).exception(ex).log();
          }
        } else {
          instance.add(key, URLDecoder.decode(parameterMap.get(key)[0], charset));
        }
      });
    }
    return instance;
  }
  
  private static final Charset charset = StandardCharsets.UTF_8;
  private static final String ENCODED = "el-encx";
 
  private final HashMap<String, String> parameters;
  
  private String url;
  
  private Parameters() {
    parameters = new HashMap<>();
  }
  
}