public override async Task <Lite <Entity> > ExecuteUniqueEntityAsync(UniqueEntityRequest request, CancellationToken token)
{
using (TypeAuthLogic.DisableQueryFilter())
{
return(await base.ExecuteUniqueEntityAsync(request, token));
}
}
public override Lite <Entity> ExecuteUniqueEntity(UniqueEntityRequest request)
{
var ex = new _EntityColumn(EntityColumnFactory().BuildColumnDescription(), QueryName);
DQueryable <T> orderQuery = Query
.ToDQueryable(GetQueryDescription())
.SelectMany(request.Multiplications)
.Where(request.Filters)
.OrderBy(request.Orders);
var result = orderQuery
.SelectOne(ex.Token)
.Unique(request.UniqueType);
return((Lite <Entity>)result);
}
public override async Task <Lite <Entity>?> ExecuteUniqueEntityAsync(UniqueEntityRequest request, CancellationToken token)
{
var ex = new _EntityColumn(EntityColumnFactory().BuildColumnDescription(), QueryName);
DQueryable <T> orderQuery = Query
.ToDQueryable(GetQueryDescription())
.SelectMany(request.Multiplications)
.Where(request.Filters)
.OrderBy(request.Orders);
var result = await orderQuery
.SelectOne(ex.Token)
.UniqueAsync(request.UniqueType, token);
return((Lite <Entity>?)result);
}
public override async Task <Lite <Entity>?> ExecuteUniqueEntityAsync(UniqueEntityRequest request, CancellationToken cancellationToken)
{
var req = new QueryRequest
{
QueryName = request.QueryName,
Filters = request.Filters,
Orders = request.Orders,
Columns = new List <Column> {
new Column(this.EntityColumnFactory().BuildColumnDescription(), QueryName)
},
Pagination = new Pagination.Firsts(2),
};
DEnumerable <T> mr = await Execute(req, GetQueryDescription(), cancellationToken);
return((Lite <Entity>)mr.Collection.Select(entitySelector.Value).Unique(request.UniqueType));
}
public static UniqueEntityRequest ToRequest(this UniqueOptions options)
{
QueryDescription qd = GetQueryDescription(options.QueryName);
FilterOption.SetFilterTokens(options.FilterOptions, qd);
OrderOption.SetOrderTokens(options.OrderOptions, qd);
var request = new UniqueEntityRequest
{
QueryName = options.QueryName,
Filters = options.FilterOptions.Select(f => f.ToFilter()).ToList(),
Orders = options.OrderOptions.Select(f => f.ToOrder()).ToList(),
UniqueType = options.UniqueType,
};
return(request);
}
protected internal virtual Lite <Entity> FindUnique(UniqueOptions options)
{
var queryDescription = DynamicQueryManager.Current.QueryDescription(options.QueryName);
FilterOption.SetFilterTokens(options.FilterOptions, queryDescription, canAggregate: false);
OrderOption.SetOrderTokens(options.OrderOptions, queryDescription, canAggregate: false);
var request = new UniqueEntityRequest
{
QueryName = options.QueryName,
Filters = options.FilterOptions.Select(f => f.ToFilter()).ToList(),
Orders = options.OrderOptions.Select(o => o.ToOrder()).ToList(),
UniqueType = options.UniqueType,
};
return(DynamicQueryManager.Current.ExecuteUniqueEntity(request));
}
public override Lite <Entity> ExecuteUniqueEntity(UniqueEntityRequest request)
{
var ex = new _EntityColumn(EntityColumnFactory().BuildColumnDescription(), QueryName);
DQueryable <T> orderQuery = Query
.ToDQueryable(GetQueryDescription())
.SelectMany(request.Multiplications)
.Where(request.Filters)
.OrderBy(request.Orders)
.Select(new List <Column> {
ex
});
var exp = Expression.Lambda <Func <object, Lite <IEntity> > >(Expression.Convert(ex.Token.BuildExpression(orderQuery.Context), typeof(Lite <IEntity>)), orderQuery.Context.Parameter);
return((Lite <Entity>)orderQuery.Query.Select(exp).Unique(request.UniqueType));
}
public Task <Lite <Entity>?> ExecuteUniqueEntityAsync(UniqueEntityRequest request, CancellationToken token)
{
return(ExecuteAsync(ExecuteType.ExecuteUniqueEntity, request.QueryName, request, dqb => dqb.Core.Value.ExecuteUniqueEntityAsync(request, token)));
}
public Lite <Entity>?ExecuteUniqueEntity(UniqueEntityRequest request)
{
return(Execute(ExecuteType.ExecuteUniqueEntity, request.QueryName, request, dqb => dqb.Core.Value.ExecuteUniqueEntity(request)));
}
public override Lite <Entity> ExecuteUniqueEntity(UniqueEntityRequest request)
{
throw new NotImplementedException();
}
public override Lite <Entity>?ExecuteUniqueEntity(UniqueEntityRequest request) => Task.Run(() => ExecuteUniqueEntityAsync(request, CancellationToken.None)).Result;
public virtual Lite <Entity> ExecuteUniqueEntity(UniqueEntityRequest request)
{
return(Return(MethodInfo.GetCurrentMethod(), request.QueryName.ToString(),
() => QueryLogic.Queries.ExecuteUniqueEntity(request)));
}
private static void QueryUniqueBatch(this UniqueEntityRequest request, Action <Lite <Entity> > onResult, Action @finally)
{
Finder.Manager.AssertFindable(request.QueryName);
Enqueue(request, obj => onResult((Lite <Entity>)obj), @finally);
}
private static Lite <Entity> QueryUnique(this UniqueEntityRequest request)
{
Finder.Manager.AssertFindable(request.QueryName);
return(Server.Return((IDynamicQueryServer s) => s.ExecuteUniqueEntity(request)));
}
public virtual Lite <Entity> ExecuteUniqueEntity(UniqueEntityRequest request)
{
return(Return(MethodInfo.GetCurrentMethod(), request.QueryName.ToString(),
() => DynamicQueryManager.Current.ExecuteUniqueEntity(request)));
}
public abstract Lite <Entity> ExecuteUniqueEntity(UniqueEntityRequest request);
