public static ColumnFilter between(Comparable low, Comparable high) { return between(null, low, high); }
public static ColumnFilter OR(ColumnFilter... filters) { return OR(null, filters); }
protected List<ColumnFilter> getColumnFilters(final String searchString) { final List<ColumnFilter> filters = new ArrayList<ColumnFilter>(); if (searchString != null && searchString.trim().length() > 0) { try { final Long instanceId = Long.valueOf(searchString.trim()); filters.add(equalsTo(COLUMN_PROCESS_INSTANCE_ID, instanceId)); } catch (NumberFormatException ex) { filters.add(equalsTo(COLUMN_PROCESS_ID, searchString)); filters.add(likeTo(COLUMN_PROCESS_NAME, "%" + searchString.toLowerCase() + "%", false)); filters.add(likeTo(COLUMN_PROCESS_INSTANCE_DESCRIPTION, "%" + searchString.toLowerCase() + "%", false)); filters.add(likeTo(COLUMN_IDENTITY, "%" + searchString.toLowerCase() + "%", false)); } } return filters; }
protected ColumnFilter createProjectFilter(WorkspaceProject project) { String repoAlias = project.getRepository().getAlias(); String projectName = project.getName(); String space = project.getOrganizationalUnit().getName(); return AND(equalsTo(COLUMN_REPO, repoAlias), equalsTo(COLUMN_PROJECT, projectName), equalsTo(COLUMN_ORG, space)); }
DataSetLookupFactory.newDataSetLookupBuilder() .dataset(EXPENSE_REPORTS) .filter(equalsTo(COLUMN_CITY, (Comparable) null)) .buildLookup()).getRowCount()).isEqualTo(1); DataSetLookupFactory.newDataSetLookupBuilder() .dataset(EXPENSE_REPORTS) .filter(equalsTo(COLUMN_CITY, Arrays.asList())) .buildLookup()).getRowCount()).isEqualTo(51); DataSetLookupFactory.newDataSetLookupBuilder() .dataset(EXPENSE_REPORTS) .filter(notEqualsTo(COLUMN_CITY, null)) .buildLookup()).getRowCount()).isEqualTo(50); DataSetLookupFactory.newDataSetLookupBuilder() .dataset(EXPENSE_REPORTS) .filter(greaterThan(COLUMN_AMOUNT, null)) .buildLookup()).getRowCount()).isEqualTo(50); DataSetLookupFactory.newDataSetLookupBuilder() .dataset(EXPENSE_REPORTS) .filter(greaterOrEqualsTo(COLUMN_AMOUNT, null)) .buildLookup()).getRowCount()).isEqualTo(51); DataSetLookupFactory.newDataSetLookupBuilder() .dataset(EXPENSE_REPORTS) .filter(lowerThan(COLUMN_AMOUNT, null)) .buildLookup()).getRowCount()).isEqualTo(0);
filter = FilterFactory.between(cg.getSourceId(), min, max); filter = FilterFactory.greaterOrEqualsTo(cg.getSourceId(), min); filter = FilterFactory.lowerOrEqualsTo(cg.getSourceId(), max); filter = FilterFactory.equalsTo(cg.getSourceId(), names);
@Test public void testCombinedExpression() throws Exception { DataSet result = dataSetManager.lookupDataSet( DataSetLookupFactory.newDataSetLookupBuilder() .dataset(EXPENSE_REPORTS) .filter(COLUMN_AMOUNT, AND( equalsTo(COLUMN_DEPARTMENT, "Sales"), OR(NOT(lowerThan(300)), equalsTo(COLUMN_CITY, "Madrid")))) .sort(COLUMN_ID, SortOrder.ASCENDING) .buildLookup()); //printDataSet(result); assertThat(result.getRowCount()).isEqualTo(7); assertDataSetValue(result, 0, 0, "9.00"); assertDataSetValue(result, 6, 0, "28.00"); }
constants.FilterByProcessInstanceId(), f -> addSearchFilter(f, equalsTo(COLUMN_PROCESS_INSTANCE_ID, f.getValue())) ); constants.FilterByInitiator(), f -> addSearchFilter(f, likeTo(COLUMN_IDENTITY, f.getValue(), false)) constants.FilterByCorrelationKey(), f -> addSearchFilter(f, likeTo(COLUMN_CORRELATION_KEY, f.getValue(), false)) constants.FilterByDescription(), f -> addSearchFilter(f, likeTo(COLUMN_PROCESS_INSTANCE_DESCRIPTION, f.getValue(), false)) constants.WithoutErrors()); final Function<String, ColumnFilter> errorFilterGenerator = (String hasErrors) -> (Boolean.valueOf(hasErrors) ? greaterThan(COLUMN_ERROR_COUNT, 0) : lowerOrEqualsTo(COLUMN_ERROR_COUNT, 0));
@Test public void testDataSetLookupMarshalling() { DataSetLookup original = DataSetLookupFactory.newDataSetLookupBuilder() .dataset("mydataset") .filter(OR(notEqualsTo("department", "IT"), greaterOrEqualsTo("amount", 100d))) .filter("department", notEqualsTo("IT")) .filter("amount", between(100d, 200d)) .filter("date", greaterThan(jsonMarshaller.parseDate("2018-01-01 00:00:00"))) .filter("country", isNull()) .group("department").select("Services") .group("date", "year").dynamic(DateIntervalType.YEAR, true) .column("date") .column("amount", AggregateFunctionType.SUM, "total") .sort("date", SortOrder.ASCENDING) .buildLookup(); JsonObject _jsonObj = jsonMarshaller.toJson(original); assertNotNull(_jsonObj.toString()); DataSetLookup unmarshalled = jsonMarshaller.fromJson(_jsonObj); assertEquals(unmarshalled, original); }
DataSetLookupFactory.newDataSetLookupBuilder() .dataset(DataSetGroupTest.EXPENSE_REPORTS) .filter(equalsTo(CITY.getName(), (Comparable) null)) .buildLookup()).getRowCount()).isEqualTo(1); DataSetLookupFactory.newDataSetLookupBuilder() .dataset(DataSetGroupTest.EXPENSE_REPORTS) .filter(equalsTo(CITY.getName(), new ArrayList<Comparable>())) .buildLookup()).getRowCount()).isEqualTo(51); DataSetLookupFactory.newDataSetLookupBuilder() .dataset(DataSetGroupTest.EXPENSE_REPORTS) .filter(notEqualsTo(CITY.getName(), null)) .buildLookup()).getRowCount()).isEqualTo(50); DataSetLookupFactory.newDataSetLookupBuilder() .dataset(DataSetGroupTest.EXPENSE_REPORTS) .filter(between(AMOUNT.getName(), null, null)) .buildLookup()).getRowCount()).isEqualTo(51); DataSetLookupFactory.newDataSetLookupBuilder() .dataset(DataSetGroupTest.EXPENSE_REPORTS) .filter(in(CITY.getName(), null)) .buildLookup()).getRowCount()).isEqualTo(51); DataSetLookupFactory.newDataSetLookupBuilder() .dataset(DataSetGroupTest.EXPENSE_REPORTS) .filter(in(CITY.getName(), new ArrayList<Comparable>())) .buildLookup()).getRowCount()).isEqualTo(51);
@Test public void testORExpression() throws Exception { DataSet result = dataSetManager.lookupDataSet( DataSetLookupFactory.newDataSetLookupBuilder() .dataset(EXPENSE_REPORTS) .filter(COLUMN_AMOUNT, OR(NOT(greaterThan(100)), greaterThan(1000), equalsTo(COLUMN_ID, 1))) .sort(COLUMN_ID, SortOrder.ASCENDING) .buildLookup()); //printDataSet(result); assertThat(result.getRowCount()).isEqualTo(8); assertDataSetValue(result, 0, 0, "1.00"); assertDataSetValue(result, 1, 0, "2.00"); assertDataSetValue(result, 7, 0, "30.00"); }
constants.FilterByProcessInstanceId(), f -> addSearchFilter(f, equalsTo(COLUMN_PROCESS_INST_ID, f.getValue())) ); constants.FilterByJobId(), f -> addSearchFilter(f, equalsTo(COLUMN_JOB_ID, f.getValue())) ); constants.FilterByErrorId(), f -> addSearchFilter(f, likeTo(COLUMN_ERROR_ID, f.getValue())) ); acks, f -> addSearchFilter(f, equalsTo(COLUMN_ERROR_ACK, Integer.valueOf(f.getValue()))) ); true, f -> addSearchFilter(f, between(COLUMN_ERROR_DATE, f.getValue().getStartDate(), f.getValue().getEndDate()))
@Test public void testCombinedExpression3() throws Exception { List<ColumnFilter> condList = new ArrayList<ColumnFilter>(); for(String employee : new String[] {"Roxie Foraker", "Patricia J. Behr", null}){ condList.add(equalsTo(employee)); } DataSet result = dataSetManager.lookupDataSet( DataSetLookupFactory.newDataSetLookupBuilder() .dataset(EXPENSE_REPORTS) // Ensure the columnId is propagated to the logical expression terms .filter(OR(COLUMN_EMPLOYEE, condList)) .column(COLUMN_ID) .sort(COLUMN_ID, SortOrder.ASCENDING) .buildLookup()); //printDataSet(result); assertDataSetValues(result, new String[][]{ {"1.00"}, {"2.00"}, {"3.00"}, {"7.00"}, {"8.00"}, {"47.00"}, {"48.00"}, {"49.00"}, {"50.00"}}, 0); }
@Test public void testANDExpression() throws Exception { DataSet result = dataSetManager.lookupDataSet( DataSetLookupFactory.newDataSetLookupBuilder() .dataset(EXPENSE_REPORTS) .filter(COLUMN_AMOUNT, AND(greaterThan(100), lowerThan(150))) .sort(COLUMN_ID, SortOrder.ASCENDING) .buildLookup()); //printDataSet(result); assertThat(result.getRowCount()).isEqualTo(1); assertDataSetValue(result, 0, 0, "1.00"); }
public static ColumnFilter likeTo(String columnId, String searchPattern) { return likeTo(columnId, searchPattern, true); }
@Test public void testDataSetGroupByHour() throws Exception { DataSet result = dataSetManager.lookupDataSet( DataSetLookupFactory.newDataSetLookupBuilder() .dataset(DataSetGroupTest.EXPENSE_REPORTS) .filter(ID.getName(), FilterFactory.AND( FilterFactory.greaterOrEqualsTo(40), FilterFactory.lowerOrEqualsTo(41))) .group(DATE.getName()).dynamic(9999, DateIntervalType.HOUR, true) .column(DATE.getName()) .buildLookup()); assertThat(result.getRowCount()).isEqualTo(25); assertThat(result.getValueAt(0,0)).isEqualTo("2012-06-12 12"); }
DataSetLookupFactory.newDataSetLookupBuilder() .dataset(EXPENSE_REPORTS) .filter(COLUMN_DATE, greaterThan(date)) .filter(COLUMN_AMOUNT, lowerOrEqualsTo(120.35)) .filter(COLUMN_CITY, notEqualsTo("Barcelona")) .sort(COLUMN_ID, SortOrder.ASCENDING) .buildLookup()); DataSetLookupFactory.newDataSetLookupBuilder() .dataset(EXPENSE_REPORTS) .filter(COLUMN_CITY, notEqualsTo("Barcelona")) .filter(COLUMN_AMOUNT, lowerOrEqualsTo(120.35)) .filter(COLUMN_DATE, greaterThan(date)) .sort(COLUMN_ID, SortOrder.ASCENDING) .buildLookup());
protected void addSearchFilterList(final String columnId, final ActiveFilterItem<List<String>> filter) { final ColumnFilter columnFilter = in(columnId, filter.getValue()); addSearchFilterList(filter, columnFilter); }
@Test public void testFilterMultiple() throws Exception { DataSet result = dataSetManager.lookupDataSet( DataSetFactory.newDataSetLookupBuilder() .dataset(EL_DATASET_UUID) .filter(ExpenseReportsData.COLUMN_AMOUNT, lowerOrEqualsTo(120.35)) .filter(ExpenseReportsData.COLUMN_CITY, equalsTo(EL_EXAMPLE_CITY_BARCELONA)) .sort(ExpenseReportsData.COLUMN_ID, SortOrder.ASCENDING) .buildLookup()); assertThat(result.getRowCount()).isEqualTo(1); assertDataSetValue(result, 0, 0, "1.00"); // The order of the filter criteria does not alter the result. result = dataSetManager.lookupDataSet( DataSetFactory.newDataSetLookupBuilder() .dataset(EL_DATASET_UUID) .filter(ExpenseReportsData.COLUMN_CITY, equalsTo(EL_EXAMPLE_CITY_BARCELONA)) .filter(ExpenseReportsData.COLUMN_AMOUNT, lowerOrEqualsTo(120.35)) .sort(ExpenseReportsData.COLUMN_ID, SortOrder.ASCENDING) .buildLookup()); assertThat(result.getRowCount()).isEqualTo(1); assertDataSetValue(result, 0, 0, "1.00"); }