JHttpQuery.java

Go to the documentation of this file.

package com.griddynamics.jagger.invoker.v2;

import org.apache.commons.lang.StringUtils;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;

import java.io.Serializable;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import static com.google.common.collect.Lists.newArrayList;


@SuppressWarnings("unused")
public class JHttpQuery<T> implements Serializable {
    public static final JHttpQuery EMPTY_QUERY = null;

    private HttpMethod method;
    private HttpHeaders headers;
    private T body;
    private Class responseBodyType;
    private Map<String, String> queryParams;
    private String path;

    public JHttpQuery<T> method(HttpMethod method) {
        this.method = method;
        return this;
    }

    public JHttpQuery<T> get() {
        return method(HttpMethod.GET);
    }

    public JHttpQuery<T> post() {
        return method(HttpMethod.POST);
    }

    public JHttpQuery<T> put() {
        return method(HttpMethod.PUT);
    }

    public JHttpQuery<T> patch() {
        return method(HttpMethod.PATCH);
    }

    public JHttpQuery<T> delete() {
        return method(HttpMethod.DELETE);
    }

    public JHttpQuery<T> trace() {
        return method(HttpMethod.TRACE);
    }

    public JHttpQuery<T> head() {
        return method(HttpMethod.HEAD);
    }

    public JHttpQuery<T> options() {
        return method(HttpMethod.OPTIONS);
    }

    public JHttpQuery<T> headers(HttpHeaders headers) {
        this.headers = headers;
        return this;
    }

    public JHttpQuery<T> headers(Map<String, List<String>> headers) {
        initHeadersIfNull();
        this.headers.putAll(headers);
        return this;
    }

    public JHttpQuery<T> header(String key, List<String> values) {
        initHeadersIfNull();
        headers.put(key, values);
        return this;
    }

    public JHttpQuery<T> header(String key, String value) {
        initHeadersIfNull();
        headers.put(key, newArrayList(value));
        return this;
    }

    public JHttpQuery<T> cookies(Map<String, String> cookies) {
        initHeadersIfNull();
        cookies.entrySet().forEach(entry -> this.headers.add("Cookie", entry.getKey() + "=" + entry.getValue()));
        return this;
    }

    public JHttpQuery<T> cookie(String name, String value) {
        initHeadersIfNull();
        this.headers.add("Cookie", name + "=" + value);
        return this;
    }

    public JHttpQuery<T> body(T body) {
        this.body = body;
        return this;
    }

    public JHttpQuery<T> responseBodyType(Class responseBodyType) {
        this.responseBodyType = responseBodyType;
        return this;
    }

    public JHttpQuery<T> queryParams(Map<String, String> queryParams) {
        this.queryParams = queryParams;
        return this;
    }

    public JHttpQuery<T> queryParam(String paramName, String paramValue) {
        if (queryParams == null)
            this.queryParams = new HashMap<>();
        this.queryParams.put(paramName, paramValue);
        return this;
    }

    public JHttpQuery<T> path(String path) {
        this.path = StringUtils.startsWith(path, "/") ? path : "/" + path;
        return this;
    }

    public JHttpQuery<T> path(String... paths) {
        String path = StringUtils.join(paths, "/");
        return path(path);
    }

    public JHttpQuery<T> path(String formatString, Object... args) {
        String path = String.format(formatString, args);
        return path(path);
    }

    public HttpMethod getMethod() {
        return method;
    }

    public T getBody() {
        return body;
    }

    public Class getResponseBodyType() {
        return responseBodyType;
    }

    public HttpHeaders getHeaders() {
        return headers;
    }

    public Map<String, String> getQueryParams() {
        return queryParams;
    }

    public String getPath() {
        return path;
    }

    private void initHeadersIfNull() {
        if (this.headers == null)
            this.headers = new HttpHeaders();
    }

    public static JHttpQuery copyOf(JHttpQuery jHttpQuery) {
        if (jHttpQuery == null)
            return null;

        JHttpQuery copy = new JHttpQuery()
                .body(jHttpQuery.getBody())
                .queryParams(jHttpQuery.getQueryParams())
                .path(jHttpQuery.getPath())
                .responseBodyType(jHttpQuery.getResponseBodyType())
                .headers(jHttpQuery.getHeaders());

        switch (jHttpQuery.getMethod()) {
            case DELETE: copy.delete(); break;
            case GET: copy.get(); break;
            case HEAD: copy.head(); break;
            case OPTIONS: copy.options(); break;
            case PATCH: copy.patch(); break;
            case POST: copy.post(); break;
            case PUT: copy.put(); break;
            case TRACE: copy.trace(); break;
        }
        return copy;
    }

    @Override
    public String toString() {
        return "JHttpQuery{" +
                "method=" + method +
                ", headers=" + headers +
                ", body=" + body +
                ", responseBodyType=" + responseBodyType +
                ", queryParams=" + queryParams +
                ", path='" + path + '\'' +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        JHttpQuery<?> httpQuery = (JHttpQuery<?>) o;

        if (method != httpQuery.method) return false;
        if (headers != null ? !headers.equals(httpQuery.headers) : httpQuery.headers != null) return false;
        if (body != null ? !body.equals(httpQuery.body) : httpQuery.body != null) return false;
        if (responseBodyType != null ? !responseBodyType.equals(httpQuery.responseBodyType) : httpQuery.responseBodyType != null)
            return false;
        if (queryParams != null ? !queryParams.equals(httpQuery.queryParams) : httpQuery.queryParams != null) return false;
        return path != null ? path.equals(httpQuery.path) : httpQuery.path == null;

    }

    @Override
    public int hashCode() {
        int result = method.hashCode();
        result = 31 * result + (headers != null ? headers.hashCode() : 0);
        result = 31 * result + (body != null ? body.hashCode() : 0);
        result = 31 * result + (responseBodyType != null ? responseBodyType.hashCode() : 0);
        result = 31 * result + (queryParams != null ? queryParams.hashCode() : 0);
        result = 31 * result + (path != null ? path.hashCode() : 0);
        return result;
    }
}