public virtual EntityViewer GetViewer <TEntity>() where TEntity : class, IEntity, new()
{
IEntityQueryable <TEntity> context = EntityBuilder.GetContext <TEntity>();
EntityMetadata metadata = EntityAnalyzer.GetMetadata <TEntity>();
EntityViewModel <TEntity> model = new EntityViewModel <TEntity>(context.OrderBy());
model.Headers = metadata.ViewProperties;
model.UpdateItems();
EntityViewer viewer = new EntityViewer(this);
viewer.Model = model;
WpfViewButton createButton = new WpfViewButton();
createButton.Name = "Create";
createButton.Command = new EntityCommand(new EntityCommand.ExecuteDelegate(t =>
{
viewer.NavigationService.Navigate(GetEditor <TEntity>(context.Create()));
}));
model.Buttons = new EntityViewButton[] { createButton };
return(viewer);
}
/// <summary>
/// Initialize entity controller.
/// </summary>
/// <param name="builder">Context builder of entity.</param>
public EntityController(IEntityContextBuilder builder)
: base(builder)
{
EntityQueryable = EntityBuilder.GetContext <TEntity>();
Metadata = EntityAnalyzer.GetMetadata <TEntity>();
PageSize = EntityViewModel.DefaultPageSizeOption;
}
public EntityProvider(ILogger <EntityProvider> logger, IEntityQueryable query,
IEntitySearcher searcher, ISignaler <EntityBase> signaler)
{
this.logger = logger;
this.query = query;
this.searcher = searcher;
this.signaler = signaler;
}
private QueryResult <TBase> Query <TEntity, TBase>(IEntityQueryable <TBase> entityQueryable, Query query, ClientInfo clientInfo)
where TEntity : TBase
where TBase : Entity
{
IEnumerable <TEntity> result = null;
long?totalCount = null;
if ((query.IncludeData ?? false) || (query.IncludeTotalCount ?? false))
{
// get filters defined by interceptors
var basefilters = GetQueryInterceptors <TBase>(clientInfo);
var filters = GetQueryInterceptors <TEntity>(clientInfo);
var baseEntityQueryable = entityQueryable
.ApplyInclude(query.IncludeList)
.ApplyFilters(basefilters);
var queryable = typeof(TEntity) == typeof(TBase)
? (IDomainQueryable <TEntity>)baseEntityQueryable
: baseEntityQueryable.OfType <TEntity>();
queryable = queryable
.ApplyFilters(filters)
.ApplyFilters(query.FilterExpressionList);
// retrieve data
if (query.IncludeData ?? false)
{
var q = queryable.ApplySorting(query.SortExpressionList);
if (query.Skip.HasValue && query.Skip.Value > 0)
{
q = q.Skip(query.Skip.Value);
}
if (query.Take.HasValue && query.Take.Value > 0)
{
q = q.Take(query.Take.Value);
}
result = ExecuteDataQuery <TEntity>(q);
}
// retrieve count
if (query.IncludeTotalCount ?? false)
{
totalCount = ExecuteCountQuery <TEntity>(queryable);
}
}
return(new QueryResult <TBase> {
Data = result, TotalCount = totalCount
});
}
internal static IEntityQueryable <TEntity> ApplyInclude <TEntity>(this IEntityQueryable <TEntity> queriable, IEnumerable <string> includeList) where TEntity : Entity
{
if (!ReferenceEquals(includeList, null))
{
foreach (var include in includeList)
{
queriable = queriable.Include(include);
}
}
return(queriable);
}
/// <summary>
/// Executes the query against the data store including query interceptors
/// </summary>
/// <returns>The result for the given query</returns>
protected virtual QueryResult <TEntity> Get <TEntity>(IEntityQueryable <TEntity> entityQueryable, Query query, ClientInfo clientInfo) where TEntity : Entity
{
if (ReferenceEquals(null, query.OfType))
{
return(Query <TEntity, TEntity>(entityQueryable, query, clientInfo));
}
else
{
var queryMethod = typeof(DataService <TRepository>)
.GetMethod("Query", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic)
.MakeGenericMethod(query.OfType.Type, typeof(TEntity));
var result = queryMethod.Invoke(this, new object[] { entityQueryable, query, clientInfo });
return((QueryResult <TEntity>)result);
}
}
