/// <summary>
/// Returns IQueryable filtered Data.
/// </summary>
/// <typeparam name="TFilter">Filter model type</typeparam>
/// <typeparam name="TList">Data model type</typeparam>
/// <param name="filterModel">Filter data</param>
/// <param name="list">Data which should be filtered</param>
/// <returns>Filtered data</returns>
public static IQueryable <TList> Filter <TFilter, TList>(TFilter filterModel, IQueryable <TList> list) where TFilter : BaseFilter
{
//Filter Model Generator
var filterGenerator = new FilterModelGenerator <TFilter>();
filterGenerator.GenerateFilterModel(filterModel);
//Query Generator
var queryGenerator = new QueryGenerator <TList>();
//Filter Parameter
if (!filterGenerator.Filters.Any())
{
return(list);
}
var filters = filterGenerator.Filters.GroupBy(f => f.PropertyName);
foreach (var filter in filters)
{
var index = 0;
foreach (var item in filter)
{
if (item.AlreadyUsed)
{
continue;
}
GenerateFilterQuery(queryGenerator, item);
var sameFilters = filterGenerator.Filters
.Where(f => f.FilterPropertyName == item.FilterPropertyName && f.PropertyName != item.PropertyName && !f.AlreadyUsed)
.ToList();
if (sameFilters.Any())
{
foreach (var sameItem in sameFilters)
{
GenerateFilterQuery(queryGenerator, sameItem);
if (!sameItem.ConditionalOperator.HasValue)
{
throw new Exception($"{nameof(item.FilterPropertyName)} does not have ConditionalOperator for filtering {item.PropertyName}"); // Add Custom Exception
}
queryGenerator.Condition(sameItem.ConditionalOperator.Value);
}
}
if (filter.Count() != 1 && index > 0 && item.ConditionalOperator.HasValue)
{
queryGenerator.Condition(item.ConditionalOperator.Value);
}
index++;
}
queryGenerator.AddFilter();
}
return(queryGenerator.ApplyFilter(list));
}
private async Task <Solution> GenerateModelFiltersAsync(
Solution solution,
ProjectId projectId,
string namespaceName,
string className,
IEnumerable <PropertyInfo> properties,
bool previewMode,
CancellationToken cancellationToken)
{
properties = properties.ToList();
if (!previewMode)
{
bool result = false;
ThreadHelper.Generic.Invoke(() =>
{
var dialog = new SelectPropertiesDialog(properties);
result = dialog.ShowModal() ?? false;
});
if (!result)
{
return(solution);
}
properties = properties.Where(p => p.Included);
}
var filterModelClass = FilterModelGenerator.FilterModelClass(className, properties);
var filterExtensionsClass = FilterExtensionsGenerator.FilterExtensionsClass(className, properties);
var filtersRoot = BaseSyntaxGenerator.CompilationUnit(namespaceName, filterModelClass, filterExtensionsClass) as SyntaxNode;
var documentId = DocumentId.CreateNewId(projectId);
solution = solution.AddDocument(documentId, className + "Filters", filtersRoot);
var newDoc = solution.GetDocument(documentId);
var options = solution.Workspace.Options
.WithChangedOption(FormattingOptions.IndentationSize, LanguageNames.CSharp, 3)
.WithChangedOption(FormattingOptions.UseTabs, LanguageNames.CSharp, true)
.WithChangedOption(FormattingOptions.NewLine, LanguageNames.CSharp, Environment.NewLine)
.WithChangedOption(FormattingOptions.SmartIndent, LanguageNames.CSharp, FormattingOptions.IndentStyle.Smart);
newDoc = await Simplifier.ReduceAsync(newDoc, Simplifier.Annotation, cancellationToken : cancellationToken).ConfigureAwait(false);
newDoc = await Formatter.FormatAsync(newDoc, Formatter.Annotation, options, cancellationToken).ConfigureAwait(false);
var formattedRoot = await newDoc.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
if (!previewMode)
{
ThreadHelper.Generic.BeginInvoke(() =>
{
solution.Workspace.OpenDocument(documentId);
});
}
return(solution.WithDocumentSyntaxRoot(documentId, formattedRoot));
}