public virtual async Task <ActionResult <IReadOnlyCollection <TReadModel> > > Select(CancellationToken cancellationToken, string q = null, string sort = null)
{
var query = new EntitySelect(q, sort);
var results = await SelectQuery(query, cancellationToken);
return(Ok(results));
}
public async Task EntitySelectQueryDeleteNested()
{
var mediator = ServiceProvider.GetService <IMediator>();
mediator.Should().NotBeNull();
var mapper = ServiceProvider.GetService <IMapper>();
mapper.Should().NotBeNull();
var filter = new EntityFilter
{
Filters = new List <EntityFilter>
{
new EntityFilter {
Name = "IsDeleted", Value = true
},
new EntityFilter {
Name = "StatusId", Value = StatusConstants.NotStarted.Id
}
}
};
var select = new EntitySelect(filter);
var selectQuery = new EntitySelectQuery <TaskReadModel>(MockPrincipal.Default, select);
var selectResult = await mediator.Send(selectQuery).ConfigureAwait(false);
selectResult.Should().NotBeNull();
}
protected virtual async Task <IReadOnlyCollection <TReadModel> > SelectQuery(EntitySelect entitySelect, CancellationToken cancellationToken = default)
{
var command = new EntitySelectQuery <TReadModel>(User, entitySelect);
var result = await Mediator.Send(command, cancellationToken);
return(result);
}
public virtual async Task <ActionResult <IReadOnlyCollection <TListModel> > > Query(CancellationToken cancellationToken, [FromQuery] string?q = null, [FromQuery] string?sort = null)
{
var query = new EntitySelect(q, sort);
var results = await SelectQuery(query, cancellationToken);
return(results.ToList());
}
public async Task <IActionResult> OnGetAsync()
{
var select = new EntitySelect();
select.Filter = CreateFilter();
select.Sort = new List <EntitySort>
{
new EntitySort {
Name = nameof(TopicListModel.CalendarYear)
},
new EntitySort {
Name = nameof(TopicListModel.TargetMonth)
},
new EntitySort {
Name = nameof(TopicListModel.Title)
}
};
var query = new EntitySelectQuery <TopicListModel>(User, select);
var topics = await Mediator.Send(query);
var fileName = $"Topics-{DateTime.Now:yyyy-MM-dd-HH-mm-ss}.csv";
return(Export(topics, fileName));
}
private async Task LoadAttendances()
{
var filter = new EntityFilter
{
Operator = EntityFilterOperators.Equal,
Name = nameof(AttendanceSessionModel.SessionId),
Value = Id
};
var select = new EntitySelect(filter);
var command = new EntitySelectQuery <AttendanceSessionModel>(User, select);
var results = await Mediator.Send(command);
Attendances = results.ToList();
}
private async Task <List <SignUpTopicReadModel> > LoadSignUpTopics()
{
var filter = new EntityFilter
{
Name = nameof(SignUpTopicReadModel.SignUpId),
Value = Id,
Operator = EntityFilterOperators.Equal
};
var select = new EntitySelect(filter);
var command = new EntitySelectQuery <SignUpTopicReadModel>(User, select);
var result = await Mediator.Send(command);
return(result
.OrderBy(p => p.TopicCalendarYear)
.ThenBy(p => p.TopicTargetMonth)
.ThenBy(p => p.TopicTitle)
.ToList());
}
private async Task <IReadOnlyCollection <TopicReadModel> > LoadTopics()
{
var filter = new EntityFilter
{
Name = nameof(TopicReadModel.CalendarYear),
Value = DateTime.Now.Year,
Operator = EntityFilterOperators.GreaterThanOrEqual
};
var select = new EntitySelect(filter);
var command = new EntitySelectQuery <TopicReadModel>(User, select);
var result = await Mediator.Send(command);
return(result
.OrderBy(p => p.CalendarYear)
.ThenBy(p => p.TargetMonth)
.ThenBy(p => p.Title)
.ToList());
}
private async Task <IReadOnlyCollection <TopicDropdownModel> > LoadTopics()
{
var select = new EntitySelect();
if (Year.HasValue)
{
var filter = new EntityFilter();
filter.Name = nameof(Core.Data.Entities.Topic.CalendarYear);
filter.Value = Year.Value;
select.Filter = filter;
}
var query = new EntitySelectQuery <TopicDropdownModel>(User, select);
var topics = await Mediator.Send(query);
return(topics
.OrderBy(p => p.Text)
.ToList());
}
public void Test_GetPostedEntities_AutoLoadPostEntitiesFalse()
{
TestRecord record = new TestRecord();
record.ID = Guid.NewGuid();
EntitySelect <TestRecord> ctrl = new EntitySelect <TestRecord>();
ctrl.AutoLoadPostEntities = false;
ctrl.EntityType = record.GetType().FullName + ", " + typeof(TestRecord).Assembly.GetName().Name;
ctrl.RequireAuthorisation = false; // Only false during testing
Guid[] ids = new Guid[] { record.ID };
SaveStrategy.New(record, false).Save(record);
IEntity[] entities = ctrl.GetPostedEntities(ids);
Assert.IsNotNull(entities, "Returned null");
// No entities should be returned because they weren't found on DataSource
Assert.AreEqual(0, entities.Length, "Invalid number of entities returned.");
}
public void Test_GetPostedEntities_AutoLoadPostEntitiesTrue()
{
TestRecord record = new TestRecord();
record.ID = Guid.NewGuid();
EntitySelect <TestRecord> ctrl = new EntitySelect <TestRecord>();
ctrl.AutoLoadPostEntities = true;
ctrl.EntityType = record.GetType().FullName + ", " + typeof(TestRecord).Assembly.GetName().Name;
ctrl.RequireAuthorisation = false; // Only false during testing
Guid[] ids = new Guid[] { record.ID };
SaveStrategy.New(record, false).Save(record);
IEntity[] entities = ctrl.GetPostedEntities(ids);
Assert.IsNotNull(entities, "Returned null");
// The entity should have been loaded automatically
Assert.AreEqual(1, entities.Length, "Invalid number of entities returned.");
}
public virtual async Task <ActionResult <IReadOnlyCollection <TReadModel> > > Select(CancellationToken cancellationToken, EntitySelect query)
{
var results = await SelectQuery(query, cancellationToken);
return(Ok(results));
}
public MemberSelectQuery(IPrincipal principal, EntitySelect select, Guid tenantId)
: base(principal, select)
{
TenantId = tenantId;
}
public virtual async Task <ActionResult <IReadOnlyCollection <TListModel> > > Query(CancellationToken cancellationToken, [FromBody] EntitySelect query)
{
var results = await SelectQuery(query, cancellationToken);
return(results.ToList());
}
public EntitySelectQuery(IPrincipal principal, EntitySelect select)
: base(principal)
{
Select = select ?? new EntitySelect();
}
