io.sphere.internal.util.QueryStringParsing Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of sphere-java-client Show documentation
sphere-java-client
There is a newer version: 0.72.1
package io.sphere.internal.util;

import com.google.common.base.Function;
import com.google.common.base.Strings;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Range;
import com.google.common.collect.Ranges;
import org.joda.time.DateTime;
import static io.sphere.internal.util.QueryStringFormat.*;

import java.math.BigDecimal;
import java.util.*;

/** Application-level query string helper (for filters & facets). */
public class QueryStringParsing {
    // ----------------------------------------------------------------
    // String
    // ----------------------------------------------------------------

    public static List parseStrings(Map queryString, String queryParam) {
        String[] values = queryString.get(queryParam);
        return values == null ? ImmutableList.of() : Arrays.asList(values);
    }

    public static String parseString(Map queryString, String queryParam) {
        return first(parseStrings(queryString, queryParam));
    }


    // ----------------------------------------------------------------
    // Double
    // ----------------------------------------------------------------

    public static List parseDoubles(Map queryString, String queryParam) {
        return parseValues(queryString, queryParam, new Function() {
            public Double apply(String v) {
                return tryParseDouble(v);
            }
        });
    }

    public static Double parseDouble(Map queryString, String queryParam) {
        return first(parseDoubles(queryString, queryParam));
    }

    public static Range parseDoubleRange(Map queryString, String queryParam) {
        return firstRange(parseDoubleRanges(queryString, queryParam));
    }


    public static List> parseDoubleRanges(Map queryString, String queryParam) {
        return parseValues(queryString, queryParam, new Function>() {
            public Range apply(String v) {
                return tryParseDoubleRange(v);
            }
        });
    }

    private static Range tryParseDoubleRange(String s) {
        return tryParseRange(s, new Function() {
            public Double apply(String v) {
                return tryParseDouble(v);
            }
        });
    }

    private static Double tryParseDouble(String v) {
        if (Strings.isNullOrEmpty(v)) return null;
        try {
            return Double.parseDouble(v);
        } catch (NumberFormatException ignored) { return null; }
    }


    // ----------------------------------------------------------------
    // BigDecimal
    // ----------------------------------------------------------------

    public static List parseDecimals(Map queryString, String queryParam) {
        return parseValues(queryString, queryParam, new Function() {
            public BigDecimal apply(String v) {
                return tryParseDecimal(v);
            }
        });
    }

    public static BigDecimal parseDecimal(Map queryString, String queryParam) {
        return first(parseDecimals(queryString, queryParam));
    }

    public static Range parseDecimalRange(Map queryString, String queryParam) {
        return firstRange(parseDecimalRanges(queryString, queryParam));
    }


    public static List> parseDecimalRanges(Map queryString, String queryParam) {
        return parseValues(queryString, queryParam, new Function>() {
            public Range apply(String v) {
                return tryParseDecimalRange(v);
            }
        });
    }

    private static Range tryParseDecimalRange(String s) {
        return tryParseRange(s, new Function() {
            public BigDecimal apply(String v) {
                return tryParseDecimal(v);
            }
        });
    }

    private static BigDecimal tryParseDecimal(String v) {
        if (Strings.isNullOrEmpty(v)) return null;
        try {
            return new BigDecimal(v);
        } catch (NumberFormatException ignored) { return null; }
    }


    // ----------------------------------------------------------------
    // DateTime
    // ----------------------------------------------------------------

    public static List parseDateTimes(Map queryString, String queryParam) {
        return parseValues(queryString, queryParam, new Function() {
            public DateTime apply(String v) {
                return tryParseDateTime(v);
            }
        });
    }

    public static DateTime parseDateTime(Map queryString, String queryParam) {
        return first(parseDateTimes(queryString, queryParam));
    }

    public static Range parseDateTimeRange(Map queryString, String queryParam) {
        return firstRange(parseDateTimeRanges(queryString, queryParam));
    }


    public static List> parseDateTimeRanges(Map queryString, String queryParam) {
        return parseValues(queryString, queryParam, new Function>() {
            public Range apply(String v) {
                return tryParseDateTimeRange(v);
            }
        });
    }

    private static Range tryParseDateTimeRange(String s) {
        return tryParseRange(s, new Function() {
            public DateTime apply(String v) {
                return tryParseDateTime(v);
            }
        });
    }

    private static DateTime tryParseDateTime(String v) {
        if (Strings.isNullOrEmpty(v)) return null;
        try {
            return dateTimeFormat.parseDateTime(v);
        } catch (IllegalArgumentException ignored) { return null; }
    }


    // ----------------------------------------------------------------
    // Helpers
    // ----------------------------------------------------------------

    private static  Range firstRange(List> list) {
        return list.isEmpty() ? Ranges.all() : list.get(0);
    }

    private static  T first(List list) {
        return list.isEmpty() ? null : list.get(0);
    }

    public static  List parseValues(Map queryString, String queryParam, Function parse) {
        String[] values = queryString.get(queryParam);
        if (values == null) return Collections.unmodifiableList(new ArrayList());
        List result = new ArrayList();
        for (String v: values) {
            T value = parse.apply(v);
            if (value != null) result.add(value);
        }
        return result;
    }

    private static Boolean isInvalidRange(String[] range) {
        return range.length != 2 || (Strings.isNullOrEmpty(range[0]) && Strings.isNullOrEmpty(range[1]));
    }

    private static  Range tryParseRange(String s, Function parse) {
        if (s == null) return Ranges.all();
        String[] r = s.split(rangeSeparator);
        if (isInvalidRange(r)) return null;
        T lower = parse.apply(r[0]);
        T upper = parse.apply(r[1]);
        Range range = lower == null ? Ranges.all() : Ranges.atLeast(lower);
        return upper == null ? range : range.intersection(Ranges.atMost(upper));
    }
}