ch.ralscha.extdirectspring.provider.RemoteProviderStoreRead.java Source code

Java tutorial

Introduction

Here is the source code for ch.ralscha.extdirectspring.provider.RemoteProviderStoreRead.java

Source

/**
 * Copyright 2010-2014 Ralph Schaer <ralphschaer@gmail.com>
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package ch.ralscha.extdirectspring.provider;

import static org.fest.assertions.api.Assertions.assertThat;
import static org.fest.assertions.api.Assertions.entry;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.format.annotation.DateTimeFormat.ISO;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.CookieValue;
import org.springframework.web.bind.annotation.RequestHeader;
import org.springframework.web.bind.annotation.RequestParam;

import ch.ralscha.extdirectspring.annotation.ExtDirectMethod;
import ch.ralscha.extdirectspring.annotation.ExtDirectMethodType;
import ch.ralscha.extdirectspring.bean.DataType;
import ch.ralscha.extdirectspring.bean.ExtDirectStoreReadRequest;
import ch.ralscha.extdirectspring.bean.ExtDirectStoreResult;
import ch.ralscha.extdirectspring.bean.Field;
import ch.ralscha.extdirectspring.bean.GroupInfo;
import ch.ralscha.extdirectspring.bean.MetaData;
import ch.ralscha.extdirectspring.bean.SortDirection;
import ch.ralscha.extdirectspring.bean.SortInfo;
import ch.ralscha.extdirectspring.filter.BooleanFilter;
import ch.ralscha.extdirectspring.filter.Comparison;
import ch.ralscha.extdirectspring.filter.DateFilter;
import ch.ralscha.extdirectspring.filter.Filter;
import ch.ralscha.extdirectspring.filter.ListFilter;
import ch.ralscha.extdirectspring.filter.NumericFilter;
import ch.ralscha.extdirectspring.filter.StringFilter;

@Service
public class RemoteProviderStoreRead {

    @ExtDirectMethod(ExtDirectMethodType.STORE_READ)
    public List<Row> method1() {
        return createRows("");
    }

    @ExtDirectMethod(value = ExtDirectMethodType.STORE_READ, event = "test")
    public List<Row> method2() {
        return null;
    }

    @ExtDirectMethod(ExtDirectMethodType.STORE_READ)
    public List<Row> method3(HttpServletResponse response, HttpServletRequest request, HttpSession session,
            Locale locale) {
        return createRows(
                ":" + (response != null) + ";" + (request != null) + ";" + (session != null) + ";" + locale);
    }

    @ExtDirectMethod(value = ExtDirectMethodType.STORE_READ, entryClass = String.class)
    public ExtDirectStoreResult<Row> method4(ExtDirectStoreReadRequest request) {
        return createExtDirectStoreResult(request, "");
    }

    @ExtDirectMethod(value = ExtDirectMethodType.STORE_READ, group = "group3")
    public ExtDirectStoreResult<Row> method5(ExtDirectStoreReadRequest request, Locale locale,
            @RequestParam(value = "id") int id) {
        assertThat(id).isEqualTo(10);
        assertThat(locale).isEqualTo(Locale.ENGLISH);

        assertThat(request.getParams().size()).isEqualTo(1);
        assertThat(request.getParams()).contains(entry("id", 10));

        return createExtDirectStoreResult(request, ":" + id + ";" + locale);
    }

    @ExtDirectMethod(value = ExtDirectMethodType.STORE_READ, group = "group2")
    public ExtDirectStoreResult<Row> method6(@RequestParam(value = "id", defaultValue = "1") int id,
            final HttpServletRequest servletRequest, ExtDirectStoreReadRequest request) {
        assertThat(id).isEqualTo(1);
        assertThat(servletRequest).isNotNull();
        return createExtDirectStoreResult(request, ":" + id + ";" + (servletRequest != null));
    }

    @ExtDirectMethod(value = ExtDirectMethodType.STORE_READ, group = "group2")
    public List<Row> method7(@RequestParam(value = "id", required = false) Integer id) {
        if (id == null) {
            assertThat(id).isNull();
        } else {
            assertThat(id).isEqualTo(Integer.valueOf(11));
        }
        return createRows(":" + id);
    }

    @ExtDirectMethod(value = ExtDirectMethodType.STORE_READ)
    public ExtDirectStoreResult<Row> method8(@DateTimeFormat(iso = ISO.DATE_TIME) Date endDate,
            final HttpServletRequest servletRequest, ExtDirectStoreReadRequest request) {
        assertThat(endDate).isNotNull();
        assertThat(servletRequest).isNotNull();
        return createExtDirectStoreResult(request, ":" + endDate.toString() + ";" + (servletRequest != null));
    }

    @ExtDirectMethod(value = ExtDirectMethodType.STORE_READ)
    public ExtDirectStoreResult<Row> method9(ExtDirectStoreReadRequest request) {
        ExtDirectStoreResult<Row> result = createExtDirectStoreResult(request, "");
        result.setMessage("everything is okay");
        return result;
    }

    @ExtDirectMethod(value = ExtDirectMethodType.STORE_READ)
    public ExtDirectStoreResult<Row> method10(ExtDirectStoreReadRequest request, Locale locale,
            @RequestParam(value = "id", required = false, defaultValue = "20") Integer id) {

        if (!id.equals(20)) {
            assertThat(id).isEqualTo(10);
            assertThat(request.getParams().size()).isEqualTo(1);
            assertThat(request.getParams()).contains(entry("id", 10));
        } else {
            assertThat(id).isEqualTo(20);
            assertThat(request.getParams().isEmpty()).isTrue();
        }
        assertThat(locale).isEqualTo(Locale.ENGLISH);

        return RemoteProviderStoreRead.createExtDirectStoreResult(request, ":" + id + ";" + locale);
    }

    @ExtDirectMethod(value = ExtDirectMethodType.STORE_READ)
    public ExtDirectStoreResult<Row> method11(ExtDirectStoreReadRequest request,
            @CookieValue(defaultValue = "defaultCookie") String cookie,
            @RequestHeader(defaultValue = "defaultHeader") String requestHeader) {
        return RemoteProviderStoreRead.createExtDirectStoreResult(request, ":" + cookie + ":" + requestHeader);
    }

    public static ExtDirectStoreResult<Row> createExtDirectStoreResult(ExtDirectStoreReadRequest request,
            final String appendix) {
        List<Row> rows = createRows(appendix);

        int totalSize = rows.size();

        if (request != null) {

            if ("name".equals(request.getQuery())) {
                for (Iterator<Row> iterator = rows.listIterator(); iterator.hasNext();) {
                    Row row = iterator.next();
                    if (!row.getName().startsWith("name")) {
                        iterator.remove();
                    }
                }
            } else if ("firstname".equals(request.getQuery())) {
                for (Iterator<Row> iterator = rows.listIterator(); iterator.hasNext();) {
                    Row row = iterator.next();
                    if (!row.getName().startsWith("firstname")) {
                        iterator.remove();
                    }
                }
            }

            totalSize = rows.size();

            Collection<SortInfo> sorters = request.getSorters();

            if (!sorters.isEmpty()) {
                SortInfo sortInfo = sorters.iterator().next();
                assertThat(sortInfo.getProperty()).isEqualTo("id");

                if (sortInfo.getDirection() == SortDirection.ASCENDING) {
                    Collections.sort(rows);
                } else {
                    Collections.sort(rows, new Comparator<Row>() {

                        // @Override
                        @Override
                        public int compare(Row o1, Row o2) {
                            return o2.getId() - o1.getId();
                        }
                    });
                }
            } else if (StringUtils.hasText(request.getSort())) {
                assertThat(request.getSort()).isEqualTo("id");

                if (request.isAscendingSort()) {
                    Collections.sort(rows);
                } else if (request.isDescendingSort()) {
                    Collections.sort(rows, new Comparator<Row>() {

                        // @Override
                        @Override
                        public int compare(Row o1, Row o2) {
                            return o2.getId() - o1.getId();
                        }
                    });
                }
            }

            Collection<GroupInfo> groups = request.getGroups();
            if (!groups.isEmpty()) {
                GroupInfo groupInfo = groups.iterator().next();

                assertThat(groupInfo.getProperty()).isEqualTo("id");
                if (groupInfo.getDirection() == SortDirection.ASCENDING) {
                    Collections.sort(rows);
                } else {
                    Collections.sort(rows, new Comparator<Row>() {

                        // @Override
                        @Override
                        public int compare(Row o1, Row o2) {
                            return o2.getId() - o1.getId();
                        }
                    });
                }

            } else if (StringUtils.hasText(request.getGroupBy())) {
                assertThat(request.getGroupBy()).isEqualTo("id");

                if (request.isAscendingGroupSort()) {
                    Collections.sort(rows);
                } else if (request.isDescendingGroupSort()) {
                    Collections.sort(rows, new Comparator<Row>() {

                        // @Override
                        @Override
                        public int compare(Row o1, Row o2) {
                            return o2.getId() - o1.getId();
                        }
                    });
                }
            }

            if (request.getStart() != null && request.getLimit() != null) {
                rows = rows.subList(request.getStart(),
                        Math.min(totalSize, request.getStart() + request.getLimit()));
            } else {
                rows = rows.subList(0, 50);
            }

        }

        return new ExtDirectStoreResult<Row>().setTotal(Long.valueOf(totalSize)).setRecords(rows)
                .setSuccess(Boolean.TRUE);

    }

    public static List<Row> createRows(String appendix) {
        List<Row> rows = new ArrayList<Row>();
        for (int i = 0; i < 100; i += 2) {
            rows.add(new Row(i, "name: " + i + appendix, true, "" + (1000 + i)));
            rows.add(new Row(i + 1, "firstname: " + (i + 1) + appendix, false, "" + (10 + i + 1)));
        }
        return rows;
    }

    @ExtDirectMethod(value = ExtDirectMethodType.STORE_READ)
    public ExtDirectStoreResult<Row> methodMetadata(ExtDirectStoreReadRequest request) {
        ExtDirectStoreResult<Row> response = createExtDirectStoreResult(request, "");

        if (request.getStart() == null && request.getSort() == null) {
            MetaData metaData = new MetaData();

            metaData.setPagingParameter(0, 50);
            metaData.setSortInfo("name", SortDirection.ASCENDING);

            Field field = new Field("id");
            field.setType(DataType.INTEGER);
            field.addCustomProperty("header", "ID");
            field.addCustomProperty("width", 20);
            field.addCustomProperty("sortable", Boolean.TRUE);
            field.addCustomProperty("resizable", Boolean.TRUE);
            field.addCustomProperty("hideable", Boolean.FALSE);
            metaData.addField(field);

            field = new Field("name");
            field.setType(DataType.STRING);
            field.addCustomProperty("header", "Name");
            field.addCustomProperty("width", 70);
            field.addCustomProperty("sortable", Boolean.TRUE);
            field.addCustomProperty("resizable", Boolean.TRUE);
            field.addCustomProperty("hideable", Boolean.FALSE);
            metaData.addField(field);

            field = new Field("admin");
            field.setType(DataType.BOOLEAN);
            field.addCustomProperty("header", "Administrator");
            field.addCustomProperty("width", 30);
            field.addCustomProperty("sortable", Boolean.TRUE);
            field.addCustomProperty("resizable", Boolean.TRUE);
            field.addCustomProperty("hideable", Boolean.TRUE);
            metaData.addField(field);

            field = new Field("salary");
            field.setType(DataType.FLOAT);
            field.addCustomProperty("header", "Salary");
            field.addCustomProperty("width", 50);
            field.addCustomProperty("sortable", Boolean.FALSE);
            field.addCustomProperty("resizable", Boolean.TRUE);
            field.addCustomProperty("hideable", Boolean.TRUE);
            metaData.addField(field);

            response.setMetaData(metaData);
        }

        return response;
    }

    @SuppressWarnings({ "rawtypes", "unchecked" })
    @ExtDirectMethod(ExtDirectMethodType.STORE_READ)
    public List<Row> methodFilter(@RequestParam("type") int type, ExtDirectStoreReadRequest request) {

        List<Filter> filters = new ArrayList<Filter>(request.getFilters());
        switch (type) {
        case 1:
        case 15: {
            assertThat(request.getFilters()).hasSize(1);
            assertThat(filters.get(0)).isInstanceOf(NumericFilter.class);

            NumericFilter nf = (NumericFilter) filters.get(0);
            assertThat(nf.getValue()).isEqualTo(2);
            assertThat(nf.getField()).isEqualTo("id");
            assertThat(nf.getComparison()).isEqualTo(Comparison.EQUAL);
            if (type == 15) {
                assertThat(nf.getRawComparison()).isEqualTo("=");
            } else {
                assertThat(nf.getRawComparison()).isEqualTo("eq");
            }

            NumericFilter nf2 = request.getFirstFilterForField("id");
            assertThat(nf2).isSameAs(nf);

            List<Filter> allFiltersForField = request.getAllFiltersForField("id");
            assertThat(allFiltersForField).hasSize(1);
            Filter nf3 = allFiltersForField.iterator().next();
            assertThat(nf3).isInstanceOf(NumericFilter.class);
            assertThat(nf3).isSameAs(nf);

            assertThat((Filter) request.getFirstFilterForField("xy")).isNull();
            assertThat(request.getAllFiltersForField("xy")).isEmpty();

            return createResult(type);
        }
        case 2:
        case 16: {
            assertThat(request.getFilters()).hasSize(2);
            assertThat(filters.get(0)).isInstanceOf(NumericFilter.class);
            assertThat(filters.get(1)).isInstanceOf(NumericFilter.class);

            NumericFilter nf = (NumericFilter) filters.get(0);
            assertThat(nf.getValue()).isEqualTo(100);
            assertThat(nf.getField()).isEqualTo("id");
            assertThat(nf.getComparison()).isEqualTo(Comparison.LESS_THAN);
            if (type == 16) {
                assertThat(nf.getRawComparison()).isEqualTo("<");
            } else {
                assertThat(nf.getRawComparison()).isEqualTo("lt");
            }

            nf = (NumericFilter) filters.get(1);
            assertThat(nf.getValue()).isEqualTo(90);
            assertThat(nf.getField()).isEqualTo("id");
            assertThat(nf.getComparison()).isEqualTo(Comparison.GREATER_THAN);
            if (type == 16) {
                assertThat(nf.getRawComparison()).isEqualTo(">");
            } else {
                assertThat(nf.getRawComparison()).isEqualTo("gt");
            }

            NumericFilter nf2 = request.getFirstFilterForField("id");
            assertThat(nf2).isSameAs((NumericFilter) filters.get(0));

            List<Filter> allFiltersForField = request.getAllFiltersForField("id");
            assertThat(allFiltersForField).containsExactly(filters.get(0), filters.get(1));

            assertThat((Filter) request.getFirstFilterForField("xy")).isNull();
            assertThat(request.getAllFiltersForField("xy")).isEmpty();

            return createResult(type);
        }
        case 3: {
            assertThat(filters).hasSize(1);
            assertThat(filters.get(0)).isInstanceOf(BooleanFilter.class);

            BooleanFilter bf1 = (BooleanFilter) filters.get(0);
            assertThat(bf1.getValue()).isEqualTo(true);
            assertThat(bf1.getField()).isEqualTo("visible");

            BooleanFilter bf2 = request.getFirstFilterForField("visible");
            assertThat(bf2).isSameAs(bf1);

            List<Filter> allFiltersForField = request.getAllFiltersForField("visible");
            assertThat(allFiltersForField).containsExactly(bf1);

            assertThat((Filter) request.getFirstFilterForField("xy")).isNull();
            assertThat(request.getAllFiltersForField("xy")).isEmpty();

            return createResult(type);
        }
        case 4: {
            assertThat(filters).hasSize(1);
            assertThat(filters.get(0)).isInstanceOf(BooleanFilter.class);

            BooleanFilter bf1 = (BooleanFilter) filters.get(0);
            assertThat(bf1.getValue()).isEqualTo(false);
            assertThat(bf1.getField()).isEqualTo("visible");

            BooleanFilter bf2 = request.getFirstFilterForField("visible");
            assertThat(bf2).isSameAs(bf1);

            List<Filter> allFiltersForField = request.getAllFiltersForField("visible");
            assertThat(allFiltersForField).containsExactly(bf1);

            return createResult(type);
        }
        case 5: {
            assertThat(filters).hasSize(1);
            assertThat(filters.get(0)).isInstanceOf(StringFilter.class);

            StringFilter sf1 = (StringFilter) filters.get(0);
            assertThat(sf1.getValue()).isEqualTo("abb");
            assertThat(sf1.getField()).isEqualTo("company");

            StringFilter sf2 = request.getFirstFilterForField("company");
            assertThat(sf2).isSameAs(sf1);

            List<Filter> allFiltersForField = request.getAllFiltersForField("company");
            assertThat(allFiltersForField).containsExactly(sf1);

            return createResult(type);
        }
        case 6: {
            assertThat(filters).hasSize(1);
            assertThat(filters.get(0)).isInstanceOf(ListFilter.class);

            ListFilter<String> lf1 = (ListFilter) filters.get(0);
            assertThat(lf1.getValue().size()).isEqualTo(1);
            assertThat(lf1.getValue().get(0)).isEqualTo("small");
            assertThat(lf1.getField()).isEqualTo("size");

            ListFilter<String> lf2 = request.getFirstFilterForField("size");
            assertThat(lf2).isSameAs(lf1);

            List<Filter> allFiltersForField = request.getAllFiltersForField("size");
            assertThat(allFiltersForField).containsExactly(lf1);

            return createResult(type);
        }
        case 7: {
            assertThat(filters).hasSize(1);
            assertThat(filters.get(0)).isInstanceOf(ListFilter.class);

            ListFilter<String> lf1 = (ListFilter) filters.get(0);
            assertThat(lf1.getValue().size()).isEqualTo(2);
            assertThat(lf1.getValue().get(0)).isEqualTo("small");
            assertThat(lf1.getValue().get(1)).isEqualTo("medium");
            assertThat(lf1.getField()).isEqualTo("size");

            ListFilter<String> lf2 = request.getFirstFilterForField("size");
            assertThat(lf2).isSameAs(lf1);

            List<Filter> allFiltersForField = request.getAllFiltersForField("size");
            assertThat(allFiltersForField).containsExactly(lf1);

            return createResult(type);
        }
        case 8:
        case 17: {
            assertThat(filters).hasSize(2);
            assertThat(filters.get(0)).isInstanceOf(DateFilter.class);
            assertThat(filters.get(1)).isInstanceOf(DateFilter.class);

            DateFilter df = (DateFilter) filters.get(0);
            assertThat(df.getValue()).isEqualTo("07/31/2010");
            assertThat(df.getField()).isEqualTo("date");
            assertThat(df.getComparison()).isEqualTo(Comparison.LESS_THAN);

            if (type == 17) {
                assertThat(df.getRawComparison()).isEqualTo("<");
            } else {
                assertThat(df.getRawComparison()).isEqualTo("lt");
            }

            df = (DateFilter) filters.get(1);
            assertThat(df.getValue()).isEqualTo("07/01/2010");
            assertThat(df.getField()).isEqualTo("date");
            assertThat(df.getComparison()).isEqualTo(Comparison.GREATER_THAN);
            if (type == 17) {
                assertThat(df.getRawComparison()).isEqualTo(">");
            } else {
                assertThat(df.getRawComparison()).isEqualTo("gt");
            }

            DateFilter df2 = request.getFirstFilterForField("date");
            assertThat(df2).isSameAs((DateFilter) filters.get(0));

            List<Filter> allFiltersForField = request.getAllFiltersForField("date");
            assertThat(allFiltersForField).containsExactly(filters.get(0), filters.get(1));

            return createResult(type);
        }
        case 9:
        case 18: {
            assertThat(filters).hasSize(1);
            assertThat(filters.get(0)).isInstanceOf(DateFilter.class);

            DateFilter df1 = (DateFilter) filters.get(0);
            assertThat(df1.getValue()).isEqualTo("07/01/2010");
            assertThat(df1.getField()).isEqualTo("date");
            assertThat(df1.getComparison()).isEqualTo(Comparison.EQUAL);
            if (type == 18) {
                assertThat(df1.getRawComparison()).isEqualTo("=");
            } else {
                assertThat(df1.getRawComparison()).isEqualTo("eq");
            }

            DateFilter df2 = request.getFirstFilterForField("date");
            assertThat(df2).isSameAs(df1);

            List<Filter> allFiltersForField = request.getAllFiltersForField("date");
            assertThat(allFiltersForField).containsExactly(df1);

            return createResult(type);
        }
        case 10: {
            assertThat(filters).hasSize(1);
            assertThat(filters.get(0)).isInstanceOf(StringFilter.class);

            StringFilter sf1 = (StringFilter) filters.get(0);
            assertThat(sf1.getValue()).isEqualTo("ERROR");
            assertThat(sf1.getField()).isEqualTo("level");

            StringFilter sf2 = request.getFirstFilterForField("level");
            assertThat(sf2).isSameAs(sf1);

            List<Filter> allFiltersForField = request.getAllFiltersForField("level");
            assertThat(allFiltersForField).containsExactly(sf1);

            return createResult(type);
        }
        case 11: {
            assertThat(request.getFilters()).hasSize(1);
            assertThat(filters.get(0)).isInstanceOf(NumericFilter.class);

            NumericFilter nf1 = (NumericFilter) filters.get(0);
            assertThat(nf1.getValue()).isEqualTo(1);
            assertThat(nf1.getField()).isEqualTo("level");
            assertThat(nf1.getComparison()).isNull();
            assertThat(nf1.getRawComparison()).isNull();

            NumericFilter nf2 = request.getFirstFilterForField("level");
            assertThat(nf2).isSameAs(nf1);

            List<Filter> allFiltersForField = request.getAllFiltersForField("level");
            assertThat(allFiltersForField).containsExactly(nf1);

            return createResult(type);
        }
        case 12: {
            assertThat(filters).hasSize(1);
            assertThat(filters.get(0)).isInstanceOf(BooleanFilter.class);

            BooleanFilter bf1 = (BooleanFilter) filters.get(0);
            assertThat(bf1.getValue()).isEqualTo(true);
            assertThat(bf1.getField()).isEqualTo("level");

            BooleanFilter bf2 = request.getFirstFilterForField("level");
            assertThat(bf2).isSameAs(bf1);

            List<Filter> allFiltersForField = request.getAllFiltersForField("level");
            assertThat(allFiltersForField).containsExactly(bf1);

            return createResult(type);
        }
        case 13: {
            assertThat(filters).hasSize(1);
            assertThat(filters.get(0)).isInstanceOf(ListFilter.class);

            ListFilter<String> lf1 = (ListFilter) filters.get(0);
            assertThat(lf1.getValue().size()).isEqualTo(1);
            assertThat(lf1.getValue().get(0)).isEqualTo("small");
            assertThat(lf1.getField()).isEqualTo("size");

            ListFilter<String> lf2 = request.getFirstFilterForField("size");
            assertThat(lf2).isSameAs(lf1);

            List<Filter> allFiltersForField = request.getAllFiltersForField("size");
            assertThat(allFiltersForField).containsExactly(lf1);

            return createResult(type);
        }
        case 14: {
            assertThat(filters).hasSize(1);
            assertThat(filters.get(0)).isInstanceOf(ListFilter.class);

            ListFilter<String> lf1 = (ListFilter) filters.get(0);
            assertThat(lf1.getValue().size()).isEqualTo(2);
            assertThat(lf1.getValue().get(0)).isEqualTo("small");
            assertThat(lf1.getValue().get(1)).isEqualTo("medium");
            assertThat(lf1.getField()).isEqualTo("size");

            ListFilter<String> lf2 = request.getFirstFilterForField("size");
            assertThat(lf2).isSameAs(lf1);

            List<Filter> allFiltersForField = request.getAllFiltersForField("size");
            assertThat(allFiltersForField).containsExactly(lf1);

            return createResult(type);
        }
        case 19: {
            assertThat(filters).hasSize(1);
            assertThat(filters.get(0)).isInstanceOf(StringFilter.class);

            StringFilter sf1 = (StringFilter) filters.get(0);
            assertThat(sf1.getValue()).isNull();
            assertThat(sf1.getField()).isEqualTo("name");

            StringFilter sf2 = request.getFirstFilterForField("name");
            assertThat(sf2).isSameAs(sf1);

            List<Filter> allFiltersForField = request.getAllFiltersForField("name");
            assertThat(allFiltersForField).containsExactly(sf1);

            return createResult(type);
        }
        case 20: {
            assertThat(filters).hasSize(1);
            assertThat(filters.get(0)).isInstanceOf(StringFilter.class);

            StringFilter sf1 = (StringFilter) filters.get(0);
            assertThat(sf1.getValue()).isNull();
            assertThat(sf1.getField()).isEqualTo("firstname");

            StringFilter sf2 = request.getFirstFilterForField("firstname");
            assertThat(sf2).isSameAs(sf1);

            List<Filter> allFiltersForField = request.getAllFiltersForField("firstname");
            assertThat(allFiltersForField).containsExactly(sf1);

            return createResult(type);
        }
        case 21: {
            assertThat(filters).hasSize(1);
            assertThat(filters.get(0)).isInstanceOf(StringFilter.class);

            StringFilter sf1 = (StringFilter) filters.get(0);
            assertThat(sf1.getValue()).isNull();
            assertThat(sf1.getField()).isEqualTo("firstname");

            StringFilter sf2 = request.getFirstFilterForField("firstname");
            assertThat(sf2).isSameAs(sf1);

            List<Filter> allFiltersForField = request.getAllFiltersForField("firstname");
            assertThat(allFiltersForField).containsExactly(sf1);

            return createResult(type);
        }
        case 22: {
            assertThat(request.getFilters()).hasSize(1);
            assertThat(filters.get(0)).isInstanceOf(NumericFilter.class);

            NumericFilter nf = (NumericFilter) filters.get(0);
            assertThat(nf.getValue()).isEqualTo(2);
            assertThat(nf.getField()).isEqualTo("id");
            assertThat(nf.getComparison()).isEqualTo(Comparison.EQUAL);
            assertThat(nf.getRawComparison()).isEqualTo("eq");

            NumericFilter nf2 = request.getFirstFilterForField("id");
            assertThat(nf2).isSameAs(nf);

            List<Filter> allFiltersForField = request.getAllFiltersForField("id");
            assertThat(allFiltersForField).hasSize(1);
            Filter nf3 = allFiltersForField.iterator().next();
            assertThat(nf3).isInstanceOf(NumericFilter.class);
            assertThat(nf3).isSameAs(nf);

            assertThat((Filter) request.getFirstFilterForField("xy")).isNull();
            assertThat(request.getAllFiltersForField("xy")).isEmpty();

            assertThat(request.getSorters()).hasSize(1);
            SortInfo sortInfo = request.getSorters().iterator().next();
            assertThat(sortInfo.getDirection()).isEqualTo(SortDirection.ASCENDING);
            assertThat(sortInfo.getProperty()).isEqualTo("company");

            return createResult(type);
        }
        case 23: {
            assertThat(request.getFilters()).hasSize(2);
            assertThat(filters.get(0)).isInstanceOf(NumericFilter.class);
            assertThat(filters.get(1)).isInstanceOf(NumericFilter.class);

            NumericFilter nf = (NumericFilter) filters.get(0);
            assertThat(nf.getValue()).isEqualTo(100);
            assertThat(nf.getField()).isEqualTo("id");
            assertThat(nf.getComparison()).isEqualTo(Comparison.LESS_THAN);
            assertThat(nf.getRawComparison()).isEqualTo("lt");

            nf = (NumericFilter) filters.get(1);
            assertThat(nf.getValue()).isEqualTo(90);
            assertThat(nf.getField()).isEqualTo("id");
            assertThat(nf.getComparison()).isEqualTo(Comparison.GREATER_THAN);
            assertThat(nf.getRawComparison()).isEqualTo("gt");

            NumericFilter nf2 = request.getFirstFilterForField("id");
            assertThat(nf2).isSameAs((NumericFilter) filters.get(0));

            List<Filter> allFiltersForField = request.getAllFiltersForField("id");
            assertThat(allFiltersForField).containsExactly(filters.get(0), filters.get(1));

            assertThat((Filter) request.getFirstFilterForField("xy")).isNull();
            assertThat(request.getAllFiltersForField("xy")).isEmpty();

            assertThat(request.getSorters()).hasSize(1);
            SortInfo sortInfo = request.getSorters().iterator().next();
            assertThat(sortInfo.getDirection()).isEqualTo(SortDirection.ASCENDING);
            assertThat(sortInfo.getProperty()).isEqualTo("company");

            return createResult(type);
        }
        case 24: {
            assertThat(filters).hasSize(1);
            assertThat(filters.get(0)).isInstanceOf(BooleanFilter.class);

            BooleanFilter bf1 = (BooleanFilter) filters.get(0);
            assertThat(bf1.getValue()).isEqualTo(true);
            assertThat(bf1.getField()).isEqualTo("visible");
            assertThat(bf1.getComparison()).isEqualTo(Comparison.EQUAL);
            assertThat(bf1.getRawComparison()).isEqualTo("=");

            BooleanFilter bf2 = request.getFirstFilterForField("visible");
            assertThat(bf2).isSameAs(bf1);

            List<Filter> allFiltersForField = request.getAllFiltersForField("visible");
            assertThat(allFiltersForField).containsExactly(bf1);

            assertThat((Filter) request.getFirstFilterForField("xy")).isNull();
            assertThat(request.getAllFiltersForField("xy")).isEmpty();

            assertThat(request.getSorters()).hasSize(1);
            SortInfo sortInfo = request.getSorters().iterator().next();
            assertThat(sortInfo.getDirection()).isEqualTo(SortDirection.ASCENDING);
            assertThat(sortInfo.getProperty()).isEqualTo("company");

            return createResult(type);
        }
        case 25: {
            assertThat(filters).hasSize(1);
            assertThat(filters.get(0)).isInstanceOf(BooleanFilter.class);

            BooleanFilter bf1 = (BooleanFilter) filters.get(0);
            assertThat(bf1.getValue()).isEqualTo(false);
            assertThat(bf1.getField()).isEqualTo("visible");
            assertThat(bf1.getComparison()).isEqualTo(Comparison.EQUAL);
            assertThat(bf1.getRawComparison()).isEqualTo("=");

            BooleanFilter bf2 = request.getFirstFilterForField("visible");
            assertThat(bf2).isSameAs(bf1);

            List<Filter> allFiltersForField = request.getAllFiltersForField("visible");
            assertThat(allFiltersForField).containsExactly(bf1);

            assertThat(request.getSorters()).hasSize(1);
            SortInfo sortInfo = request.getSorters().iterator().next();
            assertThat(sortInfo.getDirection()).isEqualTo(SortDirection.ASCENDING);
            assertThat(sortInfo.getProperty()).isEqualTo("company");

            return createResult(type);
        }
        case 26: {
            assertThat(filters).hasSize(1);
            assertThat(filters.get(0)).isInstanceOf(StringFilter.class);

            StringFilter sf1 = (StringFilter) filters.get(0);
            assertThat(sf1.getValue()).isEqualTo("abb");
            assertThat(sf1.getField()).isEqualTo("company");
            assertThat(sf1.getComparison()).isEqualTo(Comparison.LIKE);
            assertThat(sf1.getRawComparison()).isEqualTo("like");

            StringFilter sf2 = request.getFirstFilterForField("company");
            assertThat(sf2).isSameAs(sf1);

            List<Filter> allFiltersForField = request.getAllFiltersForField("company");
            assertThat(allFiltersForField).containsExactly(sf1);

            assertThat(request.getSorters()).hasSize(1);
            SortInfo sortInfo = request.getSorters().iterator().next();
            assertThat(sortInfo.getDirection()).isEqualTo(SortDirection.ASCENDING);
            assertThat(sortInfo.getProperty()).isEqualTo("company");

            return createResult(type);
        }
        case 27: {
            assertThat(filters).hasSize(1);
            assertThat(filters.get(0)).isInstanceOf(ListFilter.class);

            ListFilter<String> lf1 = (ListFilter) filters.get(0);
            assertThat(lf1.getValue().size()).isEqualTo(1);
            assertThat(lf1.getValue().get(0)).isEqualTo("small");
            assertThat(lf1.getField()).isEqualTo("size");
            assertThat(lf1.getComparison()).isEqualTo(Comparison.IN);
            assertThat(lf1.getRawComparison()).isEqualTo("in");

            ListFilter<String> lf2 = request.getFirstFilterForField("size");
            assertThat(lf2).isSameAs(lf1);

            List<Filter> allFiltersForField = request.getAllFiltersForField("size");
            assertThat(allFiltersForField).containsExactly(lf1);

            assertThat(request.getSorters()).hasSize(1);
            SortInfo sortInfo = request.getSorters().iterator().next();
            assertThat(sortInfo.getDirection()).isEqualTo(SortDirection.ASCENDING);
            assertThat(sortInfo.getProperty()).isEqualTo("company");

            return createResult(type);
        }
        case 28: {
            assertThat(filters).hasSize(1);
            assertThat(filters.get(0)).isInstanceOf(ListFilter.class);

            ListFilter<String> lf1 = (ListFilter) filters.get(0);
            assertThat(lf1.getValue().size()).isEqualTo(2);
            assertThat(lf1.getValue().get(0)).isEqualTo("small");
            assertThat(lf1.getValue().get(1)).isEqualTo("medium");
            assertThat(lf1.getField()).isEqualTo("size");
            assertThat(lf1.getComparison()).isEqualTo(Comparison.IN);
            assertThat(lf1.getRawComparison()).isEqualTo("in");

            ListFilter<String> lf2 = request.getFirstFilterForField("size");
            assertThat(lf2).isSameAs(lf1);

            List<Filter> allFiltersForField = request.getAllFiltersForField("size");
            assertThat(allFiltersForField).containsExactly(lf1);

            assertThat(request.getSorters()).hasSize(1);
            SortInfo sortInfo = request.getSorters().iterator().next();
            assertThat(sortInfo.getDirection()).isEqualTo(SortDirection.ASCENDING);
            assertThat(sortInfo.getProperty()).isEqualTo("company");

            return createResult(type);
        }
        case 29: {
            assertThat(request.getFilters()).hasSize(1);
            assertThat(filters.get(0)).isInstanceOf(NumericFilter.class);

            NumericFilter nf = (NumericFilter) filters.get(0);
            assertThat(nf.getValue()).isEqualTo(1407103200000L);
            assertThat(nf.getField()).isEqualTo("date");
            assertThat(nf.getComparison()).isEqualTo(Comparison.EQUAL);
            assertThat(nf.getRawComparison()).isEqualTo("eq");

            NumericFilter nf2 = request.getFirstFilterForField("date");
            assertThat(nf2).isSameAs(nf);

            List<Filter> allFiltersForField = request.getAllFiltersForField("date");
            assertThat(allFiltersForField).hasSize(1);
            Filter nf3 = allFiltersForField.iterator().next();
            assertThat(nf3).isInstanceOf(NumericFilter.class);
            assertThat(nf3).isSameAs(nf);

            assertThat((Filter) request.getFirstFilterForField("xy")).isNull();
            assertThat(request.getAllFiltersForField("xy")).isEmpty();

            assertThat(request.getSorters()).hasSize(1);
            SortInfo sortInfo = request.getSorters().iterator().next();
            assertThat(sortInfo.getDirection()).isEqualTo(SortDirection.ASCENDING);
            assertThat(sortInfo.getProperty()).isEqualTo("company");

            return createResult(type);
        }
        case 30: {
            assertThat(request.getFilters()).hasSize(2);
            assertThat(filters.get(0)).isInstanceOf(NumericFilter.class);
            assertThat(filters.get(1)).isInstanceOf(NumericFilter.class);

            NumericFilter nf = (NumericFilter) filters.get(0);
            assertThat(nf.getValue()).isEqualTo(1407448800000L);
            assertThat(nf.getField()).isEqualTo("date");
            assertThat(nf.getComparison()).isEqualTo(Comparison.LESS_THAN);
            assertThat(nf.getRawComparison()).isEqualTo("lt");

            nf = (NumericFilter) filters.get(1);
            assertThat(nf.getValue()).isEqualTo(1406844000000L);
            assertThat(nf.getField()).isEqualTo("date");
            assertThat(nf.getComparison()).isEqualTo(Comparison.GREATER_THAN);
            assertThat(nf.getRawComparison()).isEqualTo("gt");

            NumericFilter nf2 = request.getFirstFilterForField("date");
            assertThat(nf2).isSameAs((NumericFilter) filters.get(0));

            List<Filter> allFiltersForField = request.getAllFiltersForField("date");
            assertThat(allFiltersForField).containsExactly(filters.get(0), filters.get(1));

            assertThat((Filter) request.getFirstFilterForField("xy")).isNull();
            assertThat(request.getAllFiltersForField("xy")).isEmpty();

            assertThat(request.getSorters()).hasSize(1);
            SortInfo sortInfo = request.getSorters().iterator().next();
            assertThat(sortInfo.getDirection()).isEqualTo(SortDirection.ASCENDING);
            assertThat(sortInfo.getProperty()).isEqualTo("company");

            return createResult(type);
        }
        case 31: {
            assertThat(filters).hasSize(1);
            assertThat(filters.get(0)).isInstanceOf(ListFilter.class);

            ListFilter<Integer> lf1 = (ListFilter) filters.get(0);
            assertThat(lf1.getValue().size()).isEqualTo(1);
            assertThat(lf1.getValue().get(0)).isEqualTo(1);
            assertThat(lf1.getField()).isEqualTo("size");
            assertThat(lf1.getComparison()).isEqualTo(Comparison.IN);
            assertThat(lf1.getRawComparison()).isEqualTo("in");

            ListFilter<Integer> lf2 = request.getFirstFilterForField("size");
            assertThat(lf2).isSameAs(lf1);

            List<Filter> allFiltersForField = request.getAllFiltersForField("size");
            assertThat(allFiltersForField).containsExactly(lf1);

            assertThat(request.getSorters()).hasSize(1);
            SortInfo sortInfo = request.getSorters().iterator().next();
            assertThat(sortInfo.getDirection()).isEqualTo(SortDirection.ASCENDING);
            assertThat(sortInfo.getProperty()).isEqualTo("company");
            assertThat(request.getPage()).isEqualTo(1);
            assertThat(request.getStart()).isEqualTo(0);
            assertThat(request.getLimit()).isEqualTo(50);

            return createResult(type);
        }
        case 32: {
            assertThat(filters).hasSize(1);
            assertThat(filters.get(0)).isInstanceOf(ListFilter.class);

            ListFilter<Integer> lf1 = (ListFilter) filters.get(0);
            assertThat(lf1.getValue().size()).isEqualTo(2);
            assertThat(lf1.getValue().get(0)).isEqualTo(1);
            assertThat(lf1.getValue().get(1)).isEqualTo(2);
            assertThat(lf1.getField()).isEqualTo("size");
            assertThat(lf1.getComparison()).isEqualTo(Comparison.IN);
            assertThat(lf1.getRawComparison()).isEqualTo("in");

            ListFilter<Integer> lf2 = request.getFirstFilterForField("size");
            assertThat(lf2).isSameAs(lf1);

            List<Filter> allFiltersForField = request.getAllFiltersForField("size");
            assertThat(allFiltersForField).containsExactly(lf1);

            assertThat(request.getSorters()).hasSize(1);
            SortInfo sortInfo = request.getSorters().iterator().next();
            assertThat(sortInfo.getDirection()).isEqualTo(SortDirection.ASCENDING);
            assertThat(sortInfo.getProperty()).isEqualTo("company");
            assertThat(request.getPage()).isEqualTo(1);
            assertThat(request.getStart()).isEqualTo(0);
            assertThat(request.getLimit()).isEqualTo(50);

            return createResult(type);
        }
        case 33: {
            assertThat(filters).hasSize(1);
            assertThat(filters.get(0)).isInstanceOf(StringFilter.class);

            StringFilter sf1 = (StringFilter) filters.get(0);
            assertThat(sf1.getValue()).isEqualTo("abb");
            assertThat(sf1.getField()).isEqualTo("company");
            assertThat(sf1.getComparison()).isNull();
            assertThat(sf1.getRawComparison()).isEqualTo("fuzzy");

            StringFilter sf2 = request.getFirstFilterForField("company");
            assertThat(sf2).isSameAs(sf1);

            List<Filter> allFiltersForField = request.getAllFiltersForField("company");
            assertThat(allFiltersForField).containsExactly(sf1);

            assertThat(request.getSorters()).hasSize(1);
            SortInfo sortInfo = request.getSorters().iterator().next();
            assertThat(sortInfo.getDirection()).isEqualTo(SortDirection.ASCENDING);
            assertThat(sortInfo.getProperty()).isEqualTo("company");

            return createResult(type);
        }
        default: // do nothing
        }

        return Collections.emptyList();
    }

    private static List<Row> createResult(int i) {
        Row r = new Row(i, null, false, null);
        List<Row> result = new ArrayList<Row>();
        result.add(r);
        return result;
    }

}