private bool AddStatement(bool isFirst, FilterStatement filterStatement, List <object> parameterList, StringBuilder whereBuilder, EntitySqlFilterOperationParameters operationParameters)
{
var currentIndex = parameterList.Count;
var value = FilterTypeCorrector.ChangeType <TFilterableEntity>(filterStatement.ParameterName, filterStatement.ParameterValue);
if (value == null)
{
return(false);
}
parameterList.Add(value);
if (!isFirst)
{
if (filterStatement.LogicalOperator == FilterLogicalOperators.Or)
{
whereBuilder.Append(" OR ");
}
else
{
whereBuilder.Append(" AND ");
}
}
var columnName = CreateColumnName(filterStatement.ParameterName, operationParameters);
CreateLogicalOperation(whereBuilder, columnName, currentIndex, filterStatement.ComparisonOperator);
return(true);
}
private ISpecification <TEntity> Create(FilterStatement filter)
{
var property = typeof(TEntity).GetPropertyInfoIgnoreCase(filter.ParameterName);
if (property == null)
{
return(null);
}
var targetType = property.PropertyType;
object value = FilterTypeCorrector.ChangeType <TEntity>(filter.ParameterName, filter.ParameterValue);
if (value == null)
{
return(null);
}
if (filter.ComparisonOperator == FilterComparisonOperators.Equals)
{
return(new EqualsSpecification <TEntity>(targetType, value, filter.ParameterName));
}
if (filter.ComparisonOperator == FilterComparisonOperators.GreaterThan)
{
return(new GreaterThanSpecification <TEntity>(targetType, value, filter.ParameterName));
}
if (filter.ComparisonOperator == FilterComparisonOperators.LessThan)
{
return(new LessThanSpecification <TEntity>(targetType, value, filter.ParameterName));
}
if (filter.ComparisonOperator == FilterComparisonOperators.Contains)
{
return(new ContainsSpecification <TEntity>(filter.ParameterValue, filter.ParameterName));
}
return(null);
}
private FilterParameters ParseModel(IQueryCollection queryParameters)
{
var columnNames = queryParameters[FilterColumnName];
var groups = columnNames.GroupBy(s => s).Select(
s => new { Name = s.Key, Count = s.Count() });
var columns = groups.ToDictionary(arg => arg.Name, arg1 => arg1.Count);
var filter = new FilterParameters();
foreach (var name in columns.Keys)
{
var expectedCount = columns[name];
var valueParameter = string.Format(FilterColumnValue, name);
var values = new string[expectedCount];
if (queryParameters.ContainsKey(valueParameter))
{
var parameterValues = queryParameters[valueParameter];
values = parameterValues;
}
var operatorParameter = string.Format(FilterParameterOperator, name);
var comparisonOperators = ParseEnum(queryParameters, operatorParameter, expectedCount, FilterComparisonOperators.None);
var logicalParameter = string.Format(FilterParameterNext, name);
var logicalOperators = ParseEnum(queryParameters, logicalParameter, expectedCount, FilterLogicalOperators.None);
for (int i = 0; i < expectedCount; i++)
{
if (!string.IsNullOrWhiteSpace(values[i]) && comparisonOperators[i] != FilterComparisonOperators.None)
{
var filterStatement = new FilterStatement();
filterStatement.ParameterName = name;
filterStatement.ParameterValue = values[i];
filterStatement.ComparisonOperator = comparisonOperators[i];
filterStatement.LogicalOperator = logicalOperators[i];
filter.Statements.Add(filterStatement);
}
}
}
if (queryParameters.ContainsKey(PageSize))
{
if (int.TryParse(queryParameters[PageSize], NumberStyles.None, CultureInfo.InvariantCulture,
out var res))
{
filter.PageSize = res;
}
}
filter.PageSize = ParseInt(queryParameters, PageSize, -1);
filter.CurrentPage = ParseInt(queryParameters, CurrentPage, -1);
if (queryParameters.ContainsKey(OrderBy))
{
filter.OrderKind = ParseEnum(queryParameters, OrderKind, 1, Filterable.OrderKind.Asc).First();
filter.OrderBy = queryParameters[OrderBy];
}
return(filter);
}
