public static async Task <List <Lite <T> > > AutocompleteAsync <T>(this IQueryable <Lite <T> > query, string subString, int count, CancellationToken token)
where T : Entity
{
using (ExecutionMode.UserInterface())
{
List <Lite <T> > results = new List <Lite <T> >();
if (PrimaryKey.TryParse(subString, typeof(T), out PrimaryKey id))
{
Lite <T> entity = await query.SingleOrDefaultAsync(e => e.Id == id, token);
if (entity != null)
{
results.Add(entity);
}
if (results.Count >= count)
{
return(results);
}
}
var parts = subString.Trim('\'', '"').SplitNoEmpty(' ');
var list = await query.Where(a => a.ToString().ContainsAll(parts))
.OrderBy(a => a.ToString().Length)
.Take(count - results.Count)
.ToListAsync(token);
results.AddRange(list);
return(results);
}
}
public Func <T, bool> GetInMemoryFilter <T>(bool userInterface)
where T : Entity
{
using (userInterface ? ExecutionMode.UserInterface() : null)
{
EntityEvents <T> ee = (EntityEvents <T>)entityEvents.TryGetC(typeof(T));
if (ee == null)
{
return(a => true);
}
Func <T, bool> result = null;
foreach (var item in ee.OnFilterQuery().NotNull())
{
if (item.InMemoryFunction == null)
{
throw new InvalidOperationException("FilterQueryResult with InDatabaseExpresson '{0}' has no equivalent InMemoryFunction"
.FormatWith(item.InDatabaseExpresson.ToString()));
}
result = CombineFunc(result, item.InMemoryFunction);
}
if (result == null)
{
return(a => true);
}
return(result);
}
}
public static List <Lite <T> > Autocomplete <T>(this IEnumerable <Lite <T> > collection, string subString, int count)
where T : Entity
{
using (ExecutionMode.UserInterface())
{
List <Lite <T> > results = new List <Lite <T> >();
if (PrimaryKey.TryParse(subString, typeof(T), out PrimaryKey id))
{
Lite <T> entity = collection.SingleOrDefaultEx(e => e.Id == id);
if (entity != null)
{
results.Add(entity);
}
if (results.Count >= count)
{
return(results);
}
}
var parts = subString.Trim('\'', '"').SplitNoEmpty(' ');
var list = collection.Where(a => a.ToString().ContainsAll(parts))
.OrderBy(a => a.ToString().Length)
.Take(count - results.Count);
results.AddRange(list);
return(results);
}
}
public static async Task <List <T> > AutocompleteUntypedAsync <T>(this IQueryable <T> query, Expression <Func <T, Lite <Entity> > > entitySelector, string subString, int count, Type type, CancellationToken token)
{
using (ExecutionMode.UserInterface())
{
List <T> results = new List <T>();
if (TryParsePrimaryKey(subString, type, out PrimaryKey id))
{
T entity = await query.SingleOrDefaultAsync(r => entitySelector.Evaluate(r).Id == id);
if (entity != null)
{
results.Add(entity);
}
if (results.Count >= count)
{
return(results);
}
}
var parts = subString.Trim().SplitNoEmpty(' ');
var list = await query.Where(r => entitySelector.Evaluate(r).ToString() !.ContainsAll(parts))
.OrderBy(r => entitySelector.Evaluate(r).ToString() !.Length)
.Take(count - results.Count)
.ToListAsync();
results.AddRange(list);
return(results);
}
}
public static List <Lite <Entity> > AutocompleteUntyped(this IQueryable <Lite <Entity> > query, string subString, int count, Type type)
{
using (ExecutionMode.UserInterface())
{
List <Lite <Entity> > results = new List <Lite <Entity> >();
if (PrimaryKey.TryParse(subString, type, out PrimaryKey id))
{
Lite <Entity> entity = query.SingleOrDefaultEx(e => e.Id == id);
if (entity != null)
{
results.Add(entity);
}
if (results.Count >= count)
{
return(results);
}
}
var parts = subString.Trim('\'', '"').SplitNoEmpty(' ');
results.AddRange(query.Where(a => a.ToString().ContainsAll(parts))
.OrderBy(a => a.ToString().Length)
.Take(count - results.Count));
return(results);
}
}
public static List <Lite <T> > Autocomplete <T>(this IQueryable <Lite <T> > query, string subString, int count)
where T : Entity
{
using (ExecutionMode.UserInterface())
{
List <Lite <T> > results = new List <Lite <T> >();
if (TryParsePrimaryKey(subString, typeof(T), out PrimaryKey id))
{
Lite <T>?entity = query.SingleOrDefaultEx(e => e.Id == id);
if (entity != null)
{
results.Add(entity);
}
if (results.Count >= count)
{
return(results);
}
}
var parts = subString.SplitParts();
results.AddRange(query.Where(a => a.ToString() !.ContainsAllParts(parts))
.OrderBy(a => a.ToString() !.Length)
.Take(count - results.Count));
return(results);
}
}
static ResultTable ExecuteChart <T>(ChartRequest request, DynamicQueryCore <T> dq)
{
List <Column> columns = request.Columns.Where(c => c.Token != null).Select(t => t.CreateColumn()).ToList();
var multiplications = request.Multiplications;;
using (ExecutionMode.UserInterface())
{
if (!request.GroupResults)
{
return(dq.ExecuteQuery(new QueryRequest
{
QueryName = request.QueryName,
Columns = columns,
Filters = request.Filters,
Orders = request.Orders,
Pagination = new Pagination.All(),
}));
}
else
{
return(dq.ExecuteQueryGroup(new QueryGroupRequest
{
QueryName = request.QueryName,
Columns = columns,
Filters = request.Filters,
Orders = request.Orders
}));
}
}
}
static ResultTable ExecuteChart <T>(ChartRequestModel request, DynamicQueryCore <T> dq)
{
using (ExecutionMode.UserInterface())
{
return(dq.ExecuteQuery(new QueryRequest
{
GroupResults = request.HasAggregates(),
QueryName = request.QueryName,
Columns = request.GetQueryColumns(),
Filters = request.Filters,
Orders = request.GetQueryOrders(),
Pagination = new Pagination.All(),
}));
}
}
static async Task <ResultTable> ExecuteChartAsync <T>(ChartRequestModel request, DynamicQueryCore <T> dq, CancellationToken token)
{
using (ExecutionMode.UserInterface())
{
return(await dq.ExecuteQueryAsync(new QueryRequest
{
GroupResults = request.HasAggregates(),
QueryName = request.QueryName,
Columns = request.GetQueryColumns(),
Filters = request.Filters,
Orders = request.GetQueryOrders(),
Pagination = new Pagination.All(),
}, token));
}
}
public static async Task <List <Lite <Entity> > > FindLiteLikeAsync(Implementations implementations, string subString, int count, CancellationToken cancellationToken)
{
if (implementations.IsByAll)
{
throw new InvalidOperationException("ImplementedByAll not supported for FindLiteLike");
}
try
{
using (ExecutionMode.UserInterface())
return(await FindLiteLikeAsync(implementations.Types, subString, count, cancellationToken));
}
catch (Exception e)
{
e.Data["implementations"] = implementations.ToString();
throw;
}
}
public static List <Lite <Entity> > FindAllLite(Implementations implementations)
{
if (implementations.IsByAll)
{
throw new InvalidOperationException("ImplementedByAll is not supported for RetrieveAllLite");
}
try
{
using (ExecutionMode.UserInterface())
return(implementations.Types.SelectMany(type => Database.RetrieveAllLite(type)).ToList());
}
catch (Exception e)
{
e.Data["implementations"] = implementations.ToString();
throw;
}
}
async Task <T> ExecuteAsync <T>(ExecuteType executeType, object queryName, BaseQueryRequest request, Func <DynamicQueryBucket, Task <T> > executor)
{
using (ExecutionMode.UserInterface())
using (HeavyProfiler.Log(executeType.ToString(), () => QueryUtils.GetKey(queryName)))
{
try
{
var qb = GetQuery(queryName);
using (Disposable.Combine(QueryExecuted, f => f(executeType, queryName, request)))
{
return(await executor(qb));
}
}
catch (Exception e)
{
e.Data["QueryName"] = queryName;
throw;
}
}
}
static async Task <ResultTable> ExecuteChartAsync <T>(ChartRequestModel request, DynamicQueryCore <T> dq, CancellationToken token)
{
using (ExecutionMode.UserInterface())
{
var result = await dq.ExecuteQueryAsync(new QueryRequest
{
GroupResults = request.HasAggregates(),
QueryName = request.QueryName,
Columns = request.GetQueryColumns(),
Filters = request.Filters,
Orders = request.GetQueryOrders(),
Pagination = request.MaxRows.HasValue ? new Pagination.Firsts(request.MaxRows.Value + 1) : new Pagination.All(),
}, token);
if (request.MaxRows.HasValue && result.Rows.Length == request.MaxRows.Value)
{
throw new InvalidOperationException($"The chart request for ${request.QueryName} exceeded the max rows ({request.MaxRows})");
}
return(result);
}
}
public static async Task <List <Lite <Entity> > > FindAllLiteAsync(Implementations implementations, CancellationToken token)
{
if (implementations.IsByAll)
{
throw new InvalidOperationException("ImplementedByAll is not supported for RetrieveAllLite");
}
try
{
using (ExecutionMode.UserInterface())
{
var tasks = implementations.Types.Select(type => Database.RetrieveAllLiteAsync(type, token)).ToList();
var list = await Task.WhenAll(tasks);
return(list.SelectMany(li => li).ToList());
}
}
catch (Exception e)
{
e.Data["implementations"] = implementations.ToString();
throw;
}
}
