How to use

FieldSearchFilter

in

com.agiletec.aps.system.common

@Override
@Cacheable(value = ICacheInfoManager.DEFAULT_CACHE_NAME, key = "'GuiFragment_codesByWidgetType_'.concat(#widgetTypeCode)")
@CacheableInfo(groups = "'GuiFragment_codesByWidgetTypeGroup'")//TODO improve group handling
public List<String> getGuiFragmentCodesByWidgetType(String widgetTypeCode) throws ApsSystemException {
  List<String> codes = null;
  try {
    FieldSearchFilter filter = new FieldSearchFilter("widgettypecode", widgetTypeCode, false);
    filter.setOrder(FieldSearchFilter.Order.ASC);
    FieldSearchFilter[] filters = {filter};
    codes = this.searchGuiFragments(filters);
  } catch (Throwable t) {
    logger.error("Error loading fragments code by widget '{}'", widgetTypeCode, t);
    throw new ApsSystemException("Error loading fragment codes by widget " + widgetTypeCode, t);
  }
  return codes;
}

protected boolean appendOrderQueryBlocks(FieldSearchFilter[] filters, StringBuffer query, boolean ordered) {
  if (filters == null) {
    return ordered;
  }
  for (FieldSearchFilter filter : filters) {
    if (null != filter.getKey() && null != filter.getOrder() && !filter.isNullOption()) {
      if (!ordered) {
        query.append("ORDER BY ");
        ordered = true;
      } else {
        query.append(", ");
      }
      String fieldName = this.getTableFieldName(filter.getKey());
      query.append(this.getMasterTableName()).append(".").append(fieldName).append(" ").append(filter.getOrder());
    }
  }
  return ordered;
}

if (filter.isLikeOption() && this.isForceTextCaseSearch()) {
  return index;
if (filter.isNullOption()) {
  return index;
if (filter.getAllowedValues() != null && filter.getAllowedValues().size() > 0) {
  List<Object> allowedValues = filter.getAllowedValues();
  for (int i = 0; i < allowedValues.size(); i++) {
    Object allowedValue = allowedValues.get(i);
    this.addObjectSearchStatementBlock(stat, ++index, allowedValue, filter.isLikeOption());
} else if (filter.getValue() != null) {
  this.addObjectSearchStatementBlock(stat, ++index, filter.getValue(), filter.getValueDateDelay(), filter.isLikeOption());
} else {
  if (null != filter.getStart()) {
    this.addObjectSearchStatementBlock(stat, ++index, filter.getStart(), filter.getStartDateDelay(), false);
  if (null != filter.getEnd()) {
    this.addObjectSearchStatementBlock(stat, ++index, filter.getEnd(), filter.getEndDateDelay(), false);

public void setNullOption(boolean nullOption) {
  if (nullOption && (null != this.getValue() || null != this.getAllowedValues() || null != this.getStart() || null != this.getEnd())) {
    throw new RuntimeException("Error: the NULL cluase may be used only in conjunction with null metadata fields");
  }
  this._nullOption = nullOption;
}

protected void setLikeOption(boolean likeOption) {
  if (likeOption && ((null == this.getValue() || !(this.getValue() instanceof String)) 
        && (null == this.getAllowedValues() || this.getAllowedValues().isEmpty() || !(this.getAllowedValues().get(0) instanceof String)))) {
    throw new RuntimeException("Error: The 'like' clause cannot be applied on a null value or on a not string type");
  }
  this.likeOption = likeOption;
  if (likeOption) {
    this.setLikeOptionType(LikeOptionType.COMPLETE);
  }
}

protected void setLikeOption(boolean likeOption) {
  if (likeOption && ((null == this.getValue() || !(this.getValue() instanceof String)) 
        && (null == this.getAllowedValues() || this.getAllowedValues().isEmpty() || !(this.getAllowedValues().get(0) instanceof String)))) {
    throw new RuntimeException("Error: The 'like' clause cannot be applied on a null value or on a not string type");
  }
  this._likeOption = likeOption;
}

protected boolean addMetadataFieldFilterQueryBlock(FieldSearchFilter filter, StringBuffer query, boolean hasAppendWhereClause) {
  if (filter.isLikeOption() && this.isForceTextCaseSearch()) {
    return hasAppendWhereClause;
  String tableFieldName = this.getTableFieldName(filter.getKey());
  if (filter.getAllowedValues() != null && filter.getAllowedValues().size() > 0) {
    List<Object> allowedValues = filter.getAllowedValues();
    for (int j = 0; j < allowedValues.size(); j++) {
      if (j == 0) {
      if (filter.isLikeOption()) {
        query.append(this.getLikeClause());
      } else {
    if (filter.getValue() != null) {
      if (filter.isLikeOption()) {
        query.append(this.getLikeClause());
      } else {
      if (null != filter.getStart()) {
        query.append(">= ? ");
        if (null != filter.getEnd()) {
          query.append("AND ").append(this.getMasterTableName()).append(".").append(tableFieldName).append(" ");
          query.append("<= ? ");
      } else if (null != filter.getEnd()) {
        query.append("<= ? ");
      } else {
        if (filter.isNullOption()) {
          query.append(" IS NULL ");

protected Set<String> searchFragments(String strToSearch, String column) throws ApsSystemException {
  FieldSearchFilter filterTag = new FieldSearchFilter(column, "<@wp.fragment", true);
  FieldSearchFilter[] filters1 = new FieldSearchFilter[]{filterTag};
  List<String> result1 = this.searchGuiFragments(filters1);
  FieldSearchFilter filterCode = new FieldSearchFilter(column, strToSearch, true);
  FieldSearchFilter[] filters2 = new FieldSearchFilter[]{filterCode};
  List<String> result2 = this.searchGuiFragments(filters2);
  Set<String> result = new HashSet<>();
  result.addAll(result1);
  result.addAll(result2);
  return result;
}

@Override
public PagedMetadata<DataModelDto> getDataObjectModels(RestListRequest restListReq) {
  PagedMetadata<DataModelDto> pagedMetadata = null;
  try {
    List<FieldSearchFilter> filters = new ArrayList<>(restListReq.buildFieldSearchFilters());
    //transforms the filters by overriding the key specified in the request with the correct one known by the dto
    filters.stream().filter(searchFilter -> searchFilter.getKey() != null)
        .forEach(searchFilter -> {
          searchFilter.setKey(DataModelDto.getEntityFieldName(searchFilter.getKey()));
          if (searchFilter.getKey().equals("modelid") && null != searchFilter.getValue()) {
            String stringValue = searchFilter.getValue().toString();
            Long value = Long.parseLong(stringValue);
            searchFilter = new FieldSearchFilter("modelid", value, true);
          }
        });
    SearcherDaoPaginatedResult<DataObjectModel> models = this.getDataObjectModelManager().getDataObjectModels(filters);
    List<DataModelDto> dtoList = this.getDtoBuilder().convert(models.getList());
    pagedMetadata = new PagedMetadata<>(restListReq, models);
    pagedMetadata.setBody(dtoList);
  } catch (Throwable t) {
    logger.error("error in search data models", t);
    throw new RestServerError("error in search data models", t);
  }
  return pagedMetadata;
}

protected boolean verifyLikeFieldFilters(ResultSet result,
    FieldSearchFilter[] likeFieldFilters) throws SQLException {
  boolean verify = true;
  for (int i=0; i<likeFieldFilters.length; i++) {
    FieldSearchFilter filter = likeFieldFilters[i];
    if (filter.getKey() == null || !filter.isLikeOption() || !this.isForceTextCaseSearch()) {
      continue;
    }
    String fieldName = this.getTableFieldName(filter.getKey());
    String value = result.getString(fieldName);
    if (null != filter.getValue()) {
      verify = this.checkText((String)filter.getValue(), value);
      if (!verify) {
        break;
      }
    } else if (filter.getAllowedValues() != null && filter.getAllowedValues().size() > 0) {
      List<Object> allowedValues = filter.getAllowedValues();
      verify = this.verifyLikeAllowedValuesFilter(value, allowedValues);
      if (!verify) {
        break;
      }
    }
  }
  return verify;
}

@Test
public void shuold_create_filters() {
  RestListRequest request = new RestListRequest();
  request.setPage(1);
  request.setPageSize(25);
  request.setSort("name");
  request.setDirection(FieldSearchFilter.Order.ASC.name());
  request.addFilter(new Filter("name", "jack"));
  request.addFilter(new Filter("city", "rome"));
  request.addFilter(new Filter("mobile", "+39"));
  //filters
  List<FieldSearchFilter> filters = request.buildFieldSearchFilters();
  assertThat(filters.size(), is(5));
  assertThat(filters.get(0).getKey(), is("name"));
  assertThat(filters.get(1).getKey(), is("city"));
  assertThat(filters.get(2).getKey(), is("mobile"));
  //pagination
  assertThat(filters.get(3).getKey(), is(nullValue()));
  assertThat(filters.get(3).getLimit(), is(not(nullValue())));
  assertThat(filters.get(3).getOffset(), is(not(nullValue())));
  //sort
  assertThat(filters.get(4).getKey(), is("name"));
  assertThat(filters.get(4).getOrder(), is(FieldSearchFilter.Order.ASC));
}

List<EntitySearchFilter> entityFilters = new ArrayList<>(requestList.buildEntitySearchFilters());
filters.stream()
    .filter(i -> ((i.getKey() != null) && (UserDto.getEntityFieldName(i.getKey()) != null)))
    .forEach(i -> i.setKey(UserDto.getEntityFieldName(i.getKey())));
List<String> userNames = null;
List<UserDetails> users = new ArrayList<>(),
    -> filter.getValue() != null && filter.getKey().equals("username")).collect(Collectors.toList());
if (usernameFilter.size() > 0) {
  String text = (String) filters.get(0).getValue();
  userNames = this.getUserManager().searchUsernames(text);
} else {

@SuppressWarnings("rawtypes")
@Test
public void should_create_default_pagination() {
  RestListRequest request = new RestListRequest();
  //filters
  List<FieldSearchFilter> filters = request.buildFieldSearchFilters();
  assertThat(filters.size(), is(2));
  //pagination
  assertThat(filters.get(0).getKey(), is(nullValue()));
  assertThat(filters.get(0).getLimit(), is(not(nullValue())));
  assertThat(filters.get(0).getOffset(), is(not(nullValue())));
}

@SuppressWarnings("rawtypes")
@Override
public PagedMetadata<GroupDto> getGroups(RestListRequest restListReq) {
  try {
    //transforms the filters by overriding the key specified in the request with the correct one known by the dto
    List<FieldSearchFilter> filters = new ArrayList<FieldSearchFilter>(restListReq.buildFieldSearchFilters());
    filters
        .stream()
        .filter(i -> i.getKey() != null)
        .forEach(i -> i.setKey(GroupDto.getEntityFieldName(i.getKey())));
    SearcherDaoPaginatedResult<Group> groups = this.getGroupManager().getGroups(filters);
    List<GroupDto> dtoList = dtoBuilder.convert(groups.getList());
    PagedMetadata<GroupDto> pagedMetadata = new PagedMetadata<>(restListReq, groups);
    pagedMetadata.setBody(dtoList);
    return pagedMetadata;
  } catch (Throwable t) {
    logger.error("error in search groups", t);
    throw new RestServerError("error in search groups", t);
  }
}

@SuppressWarnings("rawtypes")
public static String createLimitBlock(FieldSearchFilter filter, DataSource dataSource, String dataSourceClass) throws NoSuchFieldException, IllegalArgumentException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
  return createLimitBlock(filter.getOffset(), filter.getLimit(), dataSource, dataSourceClass);
}

@Test
public void should_exclude_pagination_when_pagesize_0() {
  RestListRequest request = new RestListRequest();
  request.setPage(1);
  request.setPageSize(0);
  request.setSort("name");
  request.setDirection(FieldSearchFilter.Order.ASC.name());
  request.addFilter(new Filter("name", "jack"));
  request.addFilter(new Filter("city", "rome"));
  request.addFilter(new Filter("mobile", "+39"));
  //filters
  List<FieldSearchFilter> filters = request.buildFieldSearchFilters();
  assertThat(filters.size(), is(4));
  assertThat(filters.get(0).getKey(), is("name"));
  assertThat(filters.get(1).getKey(), is("city"));
  assertThat(filters.get(2).getKey(), is("mobile"));
  //sort
  assertThat(filters.get(3).getKey(), is("name"));
  assertThat(filters.get(3).getOrder(), is(FieldSearchFilter.Order.ASC));
}

protected boolean appendMetadataFieldFilterQueryBlocks(FieldSearchFilter[] filters, StringBuffer query, boolean hasAppendWhereClause) {
  if (filters == null) {
    return hasAppendWhereClause;
  }
  for (FieldSearchFilter filter : filters) {
    if (filter.getKey() != null) {
      hasAppendWhereClause = this.addMetadataFieldFilterQueryBlock(filter, query, hasAppendWhereClause);
    }
  }
  return hasAppendWhereClause;
}

private StringBuffer createMasterSelectQueryBlock(FieldSearchFilter[] filters, boolean selectAll) {
  String masterTableName = this.getMasterTableName();
  StringBuffer query = new StringBuffer("SELECT ").append(masterTableName).append(".");
  if (selectAll) {
    query.append("* ");
  } else {
    query.append(this.getMasterTableIdFieldName());
    if (this.isForceTextCaseSearch() && filters != null) {
      for (int i=0; i<filters.length; i++) {
        FieldSearchFilter filter = filters[i];
        if (filter.isLikeOption()) {
          query.append(", ").append(masterTableName).append(".").append(this.getTableFieldName(filters[i].getKey()));
        }
      }
    }
  }
  query.append(" FROM ").append(masterTableName).append(" ");
  return query;
}

private boolean checkAttributesFilter(List<FieldSearchFilter> filters, List<EntitySearchFilter> entityFilters, UserDetails user) {
  if (!filters.stream().anyMatch(filter
      -> filter.getValue() != null && filter.getKey().equals("profileType"))) {
    return true;
  }
  if (user.getProfile() == null) {
    return false;
  }
  if (!filters.stream().anyMatch(filter
      -> filter.getValue() != null && (filter.getValue().equals(((IUserProfile) user.getProfile()).getTypeCode())
      || filter.getValue().equals("All")))) {
    return false;
  }
  if (entityFilters.size() > 0) {
    try {
      EntitySearchFilter[] attributes = new EntitySearchFilter[entityFilters.size()];
      List<String> userNames = this.getUserProfileManager().searchId(entityFilters.toArray(attributes));
      if (userNames.size() == 0 || !userNames.contains(user.getUsername())) {
        return false;
      }
    } catch (ApsSystemException ex) {
      logger.error("error in filter users by profile attribute", ex);
      throw new RestServerError("error in filter users by profile attribute", ex);
    }
  }
  return true;
}

@Test
public void should_default_direction() {
  RestListRequest request = new RestListRequest();
  request.setPage(1);
  request.setPageSize(0);
  request.setSort("name");
  request.setDirection("wrong");
  //filters
  List<FieldSearchFilter> filters = request.buildFieldSearchFilters();
  assertThat(filters.size(), is(1));
  assertThat(filters.get(0).getOrder(), is(FieldSearchFilter.Order.ASC));
}