BodyQuery.java

package skyesoftware.perfectbeauty.utils;

import android.support.v4.util.ArrayMap;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * Created by norbertbanaszek on 21.09.2016.
 */

public class BodyQuery {

    public Map<String, Object> query;

    public BodyQuery(Map<String, Object> query) {
        this.query = query;
    }

    public Map<String, Object> getQuery() {
        return query;
    }

    public static class Builder {

        private Map<String, Object> request;
        private Map<String, Object> body;
        private Map<String, Object> body_query;
        private Map<String, Object> query;
        private Map<String, Object> bool;
        private Map<String, ArrayMap<String, ArrayList<String>>> filter2;
        private List<Map<String, ArrayMap<String, Object>>> must;
        private List<Map<String, ArrayMap<String, Object>>> must_not;
        private List<Map<String, ArrayMap<String, Object>>> filter;
        private List<Map<String, ArrayMap<String, Object>>> should;
        private List<Map<String, String>> sort;

        public Builder init() {
            request = new HashMap<>();
            body_query = new ArrayMap<>();
            body = new HashMap<>();
            bool = new HashMap<>();
            query = new HashMap<>();
            must = new ArrayList<>();
            must_not = new ArrayList<>();
            filter = new ArrayList<>();
            should = new ArrayList<>();
            sort = new ArrayList<>();
            filter2 = new ArrayMap<>();
            return this;
        }

        public Builder setIndex(String index) {
            request.put("index", index);
            return this;
        }
//
//        public Builder toLowercase(boolean lowercaseExpandedTerms) {
//            request.put("lowercaseExpandedTerms", lowercaseExpandedTerms);
//            return this;
//        }
//
//        public Builder withSuggestField(String suggestField) {
//            request.put("suggestField", suggestField);
//            return this;
//        }
//
//        public Builder setSuggestMode(String suggestMode) {
//            request.put("suggestMode", suggestMode);
//            return this;
//        }
//
//        public Builder setSuggestSize(int suggestSize) {
//            request.put("suggestSize", suggestSize);
//            return this;
//        }
//
//        public Builder setSuggestText(String suggestText) {
//            request.put("suggestText", suggestText);
//            return this;
//        }


        public Builder setType(String type) {
            request.put("type", type);
            return this;
        }

        public Builder setSize(String size) {
            query.put("size", size);
            return this;
        }

        public Builder setFrom(String from) {
            query.put("from", from);
            return this;
        }

        public Builder mustMatch(String key, String value) {
            if (must == null) {
                must = new ArrayList<>();
            }
            Map<String, ArrayMap<String, Object>> matching = new ArrayMap<>();
            ArrayMap<String, Object> map = new ArrayMap<>();
            map.put(key, value);
            matching.put("match", map);
            must.add(matching);
            return this;
        }

        public Builder mustTerm(String key, String value) {
            if (must == null) {
                must = new ArrayList<>();
            }
            Map<String, ArrayMap<String, Object>> matching = new ArrayMap<>();
            ArrayMap<String, Object> map = new ArrayMap<>();
            map.put(key, value);
            matching.put("term", map);
            must.add(matching);
            return this;
        }

        public Builder mustNotMatch(String key, String value) {
            if (must_not == null) {
                must_not = new ArrayList<>();
            }
            Map<String, ArrayMap<String, Object>> matching = new ArrayMap<>();
            ArrayMap<String, Object> map = new ArrayMap<>();
            map.put(key, value);
            matching.put("match", map);
            must_not.add(matching);
            return this;
        }

        public Builder mustNotTerm(String key, String value) {
            if (must_not == null) {
                must_not = new ArrayList<>();
            }
            Map<String, ArrayMap<String, Object>> matching = new ArrayMap<>();
            ArrayMap<String, Object> map = new ArrayMap<>();
            map.put(key, value);
            matching.put("match", map);
            must_not.add(matching);
            return this;
        }

        public Builder mustNotRange(String key, String from, String to) {
            if (must_not == null) {
                must_not = new ArrayList<>();
            }
            Map<String, ArrayMap<String, Object>> range = new ArrayMap<>();
            ArrayMap<String, Object> map = new ArrayMap<>();
            map.put("from", from);
            map.put("to", to);

            range.put("range", map);
            must_not.add(range);
            return this;
        }


        public Builder shouldTerm(String key, String value) {
            if (should == null) {
                should = new ArrayList<>();
            }
            Map<String, ArrayMap<String, Object>> matching = new ArrayMap<>();
            ArrayMap<String, Object> map = new ArrayMap<>();
            map.put(key, value);
            matching.put("term", map);
            should.add(matching);
            return this;
        }

        public Builder shouldMatch(String key, String value) {
            if (should == null) {
                should = new ArrayList<>();
            }
            Map<String, ArrayMap<String, Object>> matching = new ArrayMap<>();
            ArrayMap<String, Object> map = new ArrayMap<>();
            map.put(key, value);
            matching.put("match", map);
            should.add(matching);
            return this;
        }

        public Builder filterByTerm(String key, String value) {
            if (filter == null) {
                filter = new ArrayList<>();
            }
            Map<String, ArrayMap<String, Object>> filtering = new ArrayMap<>();
            ArrayMap<String, Object> map = new ArrayMap<>();
            map.put(key, value);
            filtering.put("term", map);
            filter.add(filtering);
            return this;
        }

        public Builder filterByMatch(String key, String value) {
            if (filter == null) {
                filter = new ArrayList<>();
            }
            Map<String, ArrayMap<String, Object>> filtering = new ArrayMap<>();
            ArrayMap<String, Object> map = new ArrayMap<>();
            map.put(key, value);
            filtering.put("match", map);
            filter.add(filtering);
            return this;
        }

        public Builder filterByExists(String fieldName) {
            if (filter == null) {
                filter = new ArrayList<>();
            }
            Map<String, ArrayMap<String, Object>> filtering = new ArrayMap<>();
            ArrayMap<String, Object> map = new ArrayMap<>();
            map.put("field", fieldName);
            filtering.put("exists", map);
            filter.add(filtering);
            return this;
        }

        public Builder filterByMatchPhrasePrefix(String key, String value) {
            if (filter == null) {
                filter = new ArrayList<>();
            }
            Map<String, ArrayMap<String, Object>> filtering = new ArrayMap<>();
            ArrayMap<String, Object> map = new ArrayMap<>();
            map.put(key, value);
            filtering.put("match_phrase_prefix", map);
            filter.add(filtering);
            return this;
        }

        public Builder filterByMatchPhrasePrefix2(String key, String value) {
            if (filter == null) {
                filter = new ArrayList<>();
            }
            Map<String, ArrayMap<String, Object>> filtering = new ArrayMap<>();
            HashMap<String, Object> inquery = new HashMap<>();
            inquery.put("query", value);
            inquery.put("slop", 10);
            ArrayMap<String, Object> map = new ArrayMap<>();
            map.put(key, inquery);
            filtering.put("match_phrase_prefix", map);
            filter.add(filtering);
            return this;
        }

        public Builder filterByRange(String key, String from, String to) {
            if (filter == null) {
                filter = new ArrayList<>();
            }
            Map<String, ArrayMap<String, Object>> range = new ArrayMap<>();
            ArrayMap<String, Object> map = new ArrayMap<>();
            map.put("from", from);
            map.put("to", to);

            range.put("range", map);
            filter.add(range);
            return this;
        }

        public Builder filterTerms(String key, ArrayList<String> termsList) {
            if (filter2 == null) {
                filter2 = new ArrayMap<>();
            }
            ArrayMap<String, ArrayMap<String, ArrayList<String>>> terms = new ArrayMap<>();
            ArrayMap<String, ArrayList<String>> values = new ArrayMap<>();
            values.put(key, termsList);
            filter2.put("terms", values);
            return this;
        }

        public Builder sort(String key, String value) {
            if (sort == null) {
                sort = new ArrayList<>();
            }
            ArrayMap<String, String> map = new ArrayMap<>();
            map.put(key, value);
            sort.add(map);
            return this;
        }

        public Builder returnSpecifiedFields(List<String> fields) {
            body.put("_source", fields);
            /*Allows to selectively load specific stored fields for each document represented by a search hit.
            {
                "fields" : ["user", "postDate"],
                "query" : {
                    "term" : { "user" : "kimchy" }
                }
            }*/
            return this;
        }

        /*
        "sort" : [
        { "post_date" : {"order" : "asc"}},
        "user",
        { "productName" : "desc" },
        { "age" : "desc" },
        "_score"]
        */

        /*"sort" : [
        {"price" : {"order" : "asc", "mode" : "avg"}}
        ]*/

        public Builder sortBy(String key, String sortType) {
            query.put(key, sortType);
            return this;
        }

        public Builder matchAllWithTerms(String key, ArrayList<String> termsList) {
            Map<String, Double> boost = new ArrayMap<>();
            Double val = 1.0;
            boost.put("boost", val);
            ArrayMap<String, Map<String, Double>> match_all = new ArrayMap<>();
            match_all.put("match_all", boost);

            ArrayMap<String, ArrayMap<String, ArrayList<String>>> terms = new ArrayMap<>();
            ArrayMap<String, ArrayList<String>> values = new ArrayMap<>();
            values.put(key, termsList);
            terms.put("terms", values);
            body_query.put("match_all", boost);
            body.put("filter", terms);
            return this;
        }

        public Builder matchAllWithTerms(String key, List<String> termsList) {
            Map<String, Double> boost = new ArrayMap<>();
            Double val = 1.0;
            boost.put("boost", val);
            ArrayMap<String, Map<String, Double>> match_all = new ArrayMap<>();
            match_all.put("match_all", boost);

            ArrayMap<String, ArrayMap<String, List<String>>> terms = new ArrayMap<>();
            ArrayMap<String, List<String>> values = new ArrayMap<>();
            values.put(key, termsList);
            terms.put("terms", values);
            body_query.put("match_all", boost);
            body.put("filter", terms);
            return this;

        }

        public Builder matchAll() {
            Map<String, Double> boost = new ArrayMap<>();
            Double val = 1.0;
            boost.put("boost", val);
            body_query.put("match_all", boost);
            return this;
        }

        public BodyQuery create() {
            if (!request.containsKey("index")) {
                throw new IllegalArgumentException("Index field is missing.");
            }
            if (!request.containsKey("type")) {
                throw new IllegalArgumentException("Type field is missing.");
            }
            if (must.size() > 0) {
                bool.put("must", must);
            }
            if (filter.size() > 0) {
                bool.put("filter", filter);
            }
            if (must_not.size() > 0) {
                bool.put("must_not", must_not);
            }
            if (should.size() > 0) {
                bool.put("should", should);
            }
            if (bool.size() > 0) {
                body_query.put("bool", bool);
            }
            if (body_query.size() > 0) {
                body.put("query", body_query);
            }
            if (sort.size() > 0) {
                body.put("sort", sort);
            }
            if (body.size() > 0) {
                query.put("body", body);
            }
            request.put("query", query);
            return new BodyQuery(request);
        }

        public Map<String, Object> getQuery() {
            return request;
        }

    }

    public enum BOOL {
        MUST, SHOULD
    }
}

Usage.kt

class Usage {
  private var specifiedFields: MutableList<String>? = mutableListOf()
  
  fun getQuery() : BodyQuery {
      specifiedFields?.add("field_name")
      val bodyQuery = BodyQuery.Builder().init().setType("your_type").setIndex("your_index")
                  .setSize(SIZE)
                  .sort("key", "value")
                  .mustMatch("key", "value")
                  .returnSpecifiedFields(specifiedFields)
                  .create()
    return bodyQuery.getQuery()
  
  }
}