public async Task <IEnumerable <Search> > Resolve(DocumentIOResolveFieldContext <object> context)
{
var accountId = context.GetAccountId();
var filter = context.GetFilter <SearchFilter>();
var boards = await filter.Filtered(
databaseContext.Boards.Where(x => x.Organization.Accounts.Any(account => account.Id == accountId)),
x => x,
search => search.CreatedAt)
.ToListAsync();
var columns = await filter.Filtered(
databaseContext.Columns.Where(x => x.Board.Organization.Accounts.Any(account => account.Id == accountId)),
x => x,
search => search.CreatedAt)
.ToListAsync();
var cards = await filter.Filtered(
databaseContext.Cards.Where(x =>
x.Column.Board.Organization.Accounts.Any(account => account.Id == accountId)),
x => x,
search => search.CreatedAt)
.ToListAsync();
return(boards.Concat(columns).Concat(cards));
}
public Task <int> Resolve(DocumentIOResolveFieldContext <object> context)
{
var accountId = context.GetAccountId();
var filter = context.GetFilter <BoardsFilter>();
return(filter.Filtered(
databaseContext.Boards.AsNoTracking(),
boards => boards.Where(board => board.Organization.Accounts.Any(account => account.Id == accountId)),
board => board.CreatedAt)
.CountAsync());
}
public async Task <IEnumerable <Label> > Resolve(DocumentIOResolveFieldContext <object> context)
{
var accountId = context.GetAccountId();
var filter = context.GetFilter <LabelsFilter>();
return(await filter.Filtered(
databaseContext.Labels.AsNoTracking(),
labels => labels.Where(label => label.Board.Organization.Accounts.Any(account => account.Id == accountId)),
label => label.Id)
.ToListAsync());
}
public async Task <IEnumerable <Column> > Resolve(DocumentIOResolveFieldContext <object> context)
{
var accountId = context.GetAccountId();
var filter = context.GetFilter <ColumnsFilter>();
return(await filter.Filtered(
databaseContext.Columns.AsNoTracking(),
columns => columns.Where(column =>
column.Board.Organization.Accounts.Any(account => account.Id == accountId)),
orderBy : column => column.Order)
.ToListAsync());
}
public async Task <IEnumerable <Account> > Resolve(DocumentIOResolveFieldContext <object> context)
{
var accountId = context.GetAccountId();
var filter = context.GetFilter <AccountFilter>();
return(await filter.Filtered(
databaseContext.Accounts.AsNoTracking(),
accounts => accounts.Where(
account => account.Organization.Accounts.Any(x => x.Id == accountId)),
account => account.CreatedAt)
.ToListAsync());
}
public async Task <IEnumerable <CardEvent> > Resolve(DocumentIOResolveFieldContext <object> context)
{
var accountId = context.GetAccountId();
var filter = context.GetFilter <EventsFilter>();
return(await filter.Filtered(
databaseContext.CardEvents.AsNoTracking(),
query : events => events.Where(@event =>
@event.Account.Organization.Accounts.Any(account => account.Id == accountId)),
orderBy : @event => @event.Id)
.ToListAsync());
}
public async Task <IEnumerable <Invite> > Resolve(DocumentIOResolveFieldContext <object> context)
{
var accountId = context.GetAccountId();
var filter = context.GetFilter <InvitesFilter>();
return(await filter.Filtered(
databaseContext.Invites.AsNoTracking(),
query : invites => invites
.Where(invite => invite.Organization.Accounts.Any(account => account.Id == accountId)),
orderBy : invite => invite.CreatedAt)
.ToListAsync());
}
public Task <IEnumerable <Invite> > Resolve(DocumentIOResolveFieldContext <Organization> context)
{
var filter = context.GetFilter <InvitesFilter>();
var loader = accessor.Context.GetOrAddCollectionBatchLoader <Guid, Invite>(
"OrganizationInvites",
async ids =>
await filter.Filtered(
databaseContext.Invites.AsNoTracking(),
query: invites => invites.Where(invite => ids.Contains(invite.OrganizationId)),
orderBy: invite => invite.CreatedAt)
.ToListAsync(),
invite => invite.OrganizationId);
return(loader.LoadAsync(context.Source.Id));
}
public Task <IEnumerable <Card> > Resolve(DocumentIOResolveFieldContext <Column> context)
{
var filter = context.GetFilter <CardsFilter>();
var loader = accessor.Context.GetOrAddCollectionBatchLoader <Guid, Card>(
"ColumnCards",
async ids =>
await filter.Filtered(
databaseContext.Cards.AsNoTracking(),
query: cards => cards.Where(card => ids.Contains(card.ColumnId)),
orderBy: card => card.Order)
.ToListAsync(),
card => card.ColumnId);
return(loader.LoadAsync(context.Source.Id));
}
public Task <IEnumerable <Board> > Resolve(DocumentIOResolveFieldContext <Organization> context)
{
var filter = context.GetFilter <BoardsFilter>();
var loader = accessor.Context.GetOrAddCollectionBatchLoader <Guid, Board>(
"OrganizationBoards",
async ids =>
await filter.Filtered(
databaseContext.Boards.AsNoTracking(),
boards => boards.Where(board => ids.Contains(board.OrganizationId)),
board => board.CreatedAt)
.ToListAsync(),
board => board.OrganizationId);
return(loader.LoadAsync(context.Source.Id));
}
public Task <IEnumerable <CardAttachment> > Resolve(DocumentIOResolveFieldContext <Card> context)
{
var filter = context.GetFilter <AttachmentsFilter>();
var loader = accessor.Context.GetOrAddCollectionBatchLoader <Guid, CardAttachment>(
"CardAttachment",
async ids =>
await filter.Filtered(
databaseContext.CardAttachments.AsNoTracking(),
query: attachments => attachments.Where(attachment => ids.Contains(attachment.CardId)),
orderBy: attachment => attachment.CreatedAt)
.ToListAsync(),
cardLabel => cardLabel.CardId);
return(loader.LoadAsync(context.Source.Id));
}
public Task <IEnumerable <Label> > Resolve(DocumentIOResolveFieldContext <Board> context)
{
var filter = context.GetFilter <LabelsFilter>();
var loader = accessor.Context.GetOrAddCollectionBatchLoader <Guid, Label>(
"BoardLabels",
async ids =>
await filter.Filtered(
databaseContext.Labels.AsNoTracking(),
query: labels => labels.Where(label => ids.Contains(label.BoardId)),
orderBy: label => label.Id)
.ToListAsync(),
label => label.BoardId);
return(loader.LoadAsync(context.Source.Id));
}
public Task <IEnumerable <CardEvent> > Resolve(DocumentIOResolveFieldContext <Account> context)
{
var filter = context.GetFilter <EventsFilter>();
var loader = accessor.Context.GetOrAddCollectionBatchLoader <Guid, CardEvent>(
"AccountEvents",
async ids =>
await filter.Filtered(
databaseContext.CardEvents.AsNoTracking(),
events => events.Where(cardLabel => ids.Contains(cardLabel.AccountId)),
@event => @event.CreatedAt)
.ToListAsync(),
cardLabel => cardLabel.AccountId);
return(loader.LoadAsync(context.Source.Id));
}
public async Task <IEnumerable <Account> > Resolve(DocumentIOResolveFieldContext <Card> context)
{
var filter = context.GetFilter <AccountFilter>();
var loader = accessor.Context.GetOrAddCollectionBatchLoader <Guid, CardAssignment>(
"CardAssignments",
async ids =>
await filter.Filtered(
databaseContext.Accounts.AsNoTracking(),
query: accounts => accounts.SelectMany(account => account.Assignments)
.Include(cardLabel => cardLabel.Account)
.Where(cardLabel => ids.Contains(cardLabel.CardId)),
orderBy: assignment => assignment.CreatedAt)
.ToListAsync(),
cardLabel => cardLabel.CardId);
var cardLabels = await loader.LoadAsync(context.Source.Id);
return(cardLabels.Select(cardLabel => cardLabel.Account).ToList());
}
public async Task <IEnumerable <Card> > Resolve(DocumentIOResolveFieldContext <Label> context)
{
var filter = context.GetFilter <CardsFilter>();
var loader = accessor.Context.GetOrAddCollectionBatchLoader <Guid, CardLabel>(
"LabelCards",
async ids =>
await filter.Filtered(
databaseContext.Cards.AsNoTracking(),
cards => cards
.SelectMany(card => card.Labels)
.Include(cardLabel => cardLabel.Card)
.Where(cardLabel => ids.Contains(cardLabel.LabelId)),
label => label.CardId)
.ToListAsync(),
cardLabel => cardLabel.LabelId);
var cardLabels = await loader.LoadAsync(context.Source.Id);
return(cardLabels.Select(cardLabel => cardLabel.Card).ToList());
}