public virtual SpecificationDbQuery <TEntity> SpecificationQuery(
IncludeSpecification <TEntity> includeSpecification,
FilterSpecification <TEntity> filterSpecification,
OrderBySpecification <TEntity> orderBySpecification,
int?skip = null,
int?take = null,
bool getFullGraph = false)
{
var specification = new SpecificationDbQuery <TEntity>(context).Include(includeSpecification).Where(filterSpecification).OrderBy(orderBySpecification);
if (skip.HasValue)
{
specification = specification.Skip(skip.Value);
}
if (take.HasValue)
{
specification = specification.Take(take.Value);
}
if (getFullGraph)
{
specification = specification.FullGraph();
}
return(specification);
}
public virtual PagedList <TDto> Search(
IncludeSpecification <TDto> includeSpecification,
FilterSpecification <TDto> filterSpecification,
OrderBySpecification <TDto> orderBySpecification,
int?pageNo = null,
int?pageSize = null,
bool getFullGraph = false)
{
var filterConverted = filterSpecification.Map <TEntity>(Mapper);
if (!OrderByMapper.ValidOrderByFor <TDto, TEntity>(orderBySpecification.OrderByString))
{
throw new BadRequestException(Messages.OrderByInvalid);
}
//Ideally OrderByMapper could also convert Expressions but it only handles strings.
var orderByConverted = string.IsNullOrEmpty(orderBySpecification.OrderByString) ? orderBySpecification.Map <TEntity>(Mapper) : orderBySpecification.Map <TEntity>(OrderByMapper);
var includesConverted = includeSpecification.Map <TEntity>(Mapper);
int?skip = null;
if (pageNo.HasValue && pageSize.HasValue)
{
skip = (pageNo.Value - 1) * pageSize.Value;
}
var entityList = Repository.SpecificationQuery(includesConverted, filterConverted, orderByConverted, skip, pageSize, GetFullGraph || getFullGraph).ToCountList();
var entities = entityList.ToList();
var dtoList = new PagedList <TDto>(entities.Select(Mapper.Map <TEntity, TDto>).ToList(), entityList.TotalCount, pageNo ?? 1, pageSize ?? entityList.TotalCount);
return(dtoList);
}
public V GetSearchInformation <T, U, V>() where T : IDatatableBaseConfiguration where U : IBaseEntity where V : ISpecification <U>
{
Type searchType = typeof(T).BaseType.GetGenericArguments()[0];
var searchResult = createObjectWithDefaultConstructor(searchType);
var orderBySpecification = new OrderBySpecification <string>(SortInformation.Item1, !SortInformation.Item2);
if (searchResult != null && IsTypeImplementInterface(searchType, typeof(ISpecification <U>)))
{
if (AdditionalParameters != null && AdditionalParameters.Count > 0)
{
searchResult = AdditionalParameters.ToObject(searchResult);
}
((ISpecification <U>)searchResult).Skip = Start;
((ISpecification <U>)searchResult).Take = Length;
((ISpecification <U>)searchResult).OrderByStrings = new List <OrderBySpecification <string> >()
{
orderBySpecification
};
}
var instance = createObjectWithDefaultConstructor(typeof(T)) as IDatatableBaseConfiguration;
var filterColum = instance.Columns.FirstOrDefault(x => string.Compare(orderBySpecification.OrderBy, x.Name, true) == 0 && !string.IsNullOrEmpty(x.SortDataSource));
if (filterColum != null)
{
orderBySpecification.OrderBy = filterColum.SortDataSource;
}
return((V)searchResult);
}
static async Task Main(string[] args)
{
var services = new ServiceCollection()
.AddElsa(configure => configure
.AddConsoleActivities()
.AddFileActivities())
.AddAutoMapperProfiles <Program>()
.BuildServiceProvider();
// Run startup actions (not needed when registering Elsa with a Host).
var startupRunner = services.GetRequiredService <IStartupRunner>();
await startupRunner.StartupAsync();
// Get a workflow runner.
var workflowRunner = services.GetRequiredService <IBuildsAndStartsWorkflow>();
// Run the workflow.
await workflowRunner.BuildAndStartWorkflowAsync <ReadLineToFileWorkflow>();
var store = services.GetRequiredService <IWorkflowInstanceStore>();
var results = await store.FindManyAsync(
new WorkflowDefinitionIdSpecification(nameof(ReadLineToFileWorkflow)),
OrderBySpecification.OrderByDescending <WorkflowInstance>(x => x.CreatedAt),
Paging.Page(1, 2));
var count = await store.CountAsync(new WorkflowDefinitionIdSpecification(nameof(ReadLineToFileWorkflow)));
Console.WriteLine(count);
foreach (var result in results)
{
Console.WriteLine(result.CreatedAt);
}
}
public async Task <IActionResult> Get(CancellationToken cancellationToken)
{
var instances = await this.instanceStore.FindManyAsync(
new WorkflowInstanceAllSpecification(),
OrderBySpecification.OrderByDescending <WorkflowInstance>(x => x.CreatedAt));
return(new JsonResult(instances));
}
public async Task <ActionResult <PagedList <WorkflowExecutionLogRecord> > > Handle(string id, int?page = default, int?pageSize = default, CancellationToken cancellationToken = default)
{
var specification = new WorkflowInstanceIdSpecification(id);
var totalCount = await _workflowExecutionLogStore.CountAsync(specification, cancellationToken);
var paging = page != null?Paging.Page(page.Value, pageSize ?? 100) : default;
var orderBy = OrderBySpecification.OrderBy <WorkflowExecutionLogRecord>(x => x.Timestamp);
var records = await _workflowExecutionLogStore.FindManyAsync(specification, orderBy, paging, cancellationToken).ToList();
return(new PagedList <WorkflowExecutionLogRecord>(records, page, pageSize, totalCount));
}
public async Task <IActionResult> Get(string correlationId, CancellationToken cancellationToken)
{
if (string.IsNullOrEmpty(correlationId))
{
this.Response.StatusCode = StatusCodes.Status400BadRequest;
return(new EmptyResult());
}
var instances = await this.instanceStore.FindManyAsync(
new WorkflowInstanceCorrelationIdSpecification(correlationId),
OrderBySpecification.OrderByDescending <WorkflowInstance>(x => x.CreatedAt));
return(new JsonResult(instances));
}
public virtual async Task <PagedList <TDto> > SearchAsync(
IncludeSpecification <TDto> includeSpecification,
FilterSpecification <TDto> filterSpecification,
OrderBySpecification <TDto> orderBySpecification,
int?pageNo = null,
int?pageSize = null,
bool getFullGraph = false,
CancellationToken cancellationToken = default(CancellationToken))
{
await AuthorizeResourceOperationAsync(ResourceCollectionsCore.CRUD.Operations.Read, ResourceCollectionsCore.CRUD.Operations.ReadOwner);
var filterConverted = filterSpecification.Map <TEntity>(Mapper);
if (!OrderByMapper.ValidOrderByFor <TDto, TEntity>(orderBySpecification.OrderByString))
{
throw new BadRequestError(Messages.OrderByInvalid);
}
//Ideally OrderByMapper could also convert Expressions but it only handles strings.
var orderByConverted = string.IsNullOrEmpty(orderBySpecification.OrderByString) ? orderBySpecification.Map <TEntity>(Mapper) : orderBySpecification.Map <TEntity>(OrderByMapper);
var includesConverted = includeSpecification.Map <TEntity>(Mapper);
int?skip = null;
if (pageNo.HasValue && pageSize.HasValue)
{
skip = (pageNo.Value - 1) * pageSize.Value;
}
var entityList = await Repository.SpecificationQuery(includesConverted, filterConverted, orderByConverted, skip, pageSize, GetFullGraph || getFullGraph).ToCountListAsync(cancellationToken).ConfigureAwait(false);
var entities = entityList.ToList();
foreach (var entity in entities)
{
await AuthorizeResourceOperationAsync(entity, ResourceCollectionsCore.CRUD.Operations.Read, ResourceCollectionsCore.CRUD.Operations.ReadOwner);
}
var dtoList = new PagedList <TDto>(entities.Select(Mapper.Map <TEntity, TDto>).ToList(), entityList.TotalCount, pageNo ?? 1, pageSize ?? entityList.TotalCount);
return(dtoList);
}
public async Task <ActionResult <ActivityStats> > Handle(string workflowInstanceId, string activityId, CancellationToken cancellationToken = default)
{
var specification = new WorkflowInstanceIdSpecification(workflowInstanceId).And(new ActivityIdSpecification(activityId));
var orderBy = OrderBySpecification.OrderBy <WorkflowExecutionLogRecord>(x => x.Timestamp);
var records = await _workflowExecutionLogStore.FindManyAsync(specification, orderBy, null, cancellationToken).ToList();
var eventCounts = records.GroupBy(x => x.EventName).ToList();
var executions = GetExecutions(records).ToList();
var executionTimes = executions.Select(x => x.Duration).OrderBy(x => x).ToList();
var faultRecord = records.FirstOrDefault(x => x.EventName == "Faulted");
var activityFault = faultRecord != null ? new ActivityFault(faultRecord.Message !) : null;
var model = new ActivityStats
{
EventCounts = eventCounts.Select(x => new ActivityEventCount(x.Key !, x.Count())).ToList(),
LastExecutedAt = executions.Select(x => x.Timestamp).OrderByDescending(x => x).FirstOrDefault(),
SlowestExecutionTime = executionTimes.LastOrDefault(),
FastestExecutionTime = executionTimes.FirstOrDefault(),
AverageExecutionTime = executionTimes.Any() ? Duration.FromTicks(executionTimes.Average(x => x.TotalTicks)) : default,
public IEnumerable <T> FindNoTracking <TKey>(
Specification <T> specification = null,
OrderBySpecification <T, TKey> orderBySpecification = null,
int pageNumber = 1,
int pageSize = int.MaxValue)
{
var query = _dbSet as IQueryable <T>;
if (specification != null)
{
query = query.Where(specification.ToExpression());
}
if (orderBySpecification != null)
{
query = query.OrderBy(orderBySpecification.ToExpression());
}
query = query.Skip((pageNumber - 1) * pageSize).Take(pageSize);
return(query.AsNoTracking()
.AsEnumerable());
}
public QueryWithProjectionBuilder <T, TResult> AddOrderByDescending(OrderBySpecification <T> specification)
{
this.query.AddOrderByDescending(specification);
return(this);
}
public virtual void AddOrderByDescending(OrderBySpecification <T> specification)
{
this.OrderByDescending = specification.ToOrderByExpression();
}
public IQueryBuilder <T> AddOrderByDescending(OrderBySpecification <T> specification)
{
this.query.AddOrderByDescending(specification);
return(this);
}
