public async Task <IActionResult> GetAccounts([FromQuery] QueryParametersRequest queryParameters)
{
var query = new GetAccountsQuery(_mapper.Map <QueryParameters <Account> >(queryParameters));
var result = await _bus.Send(query);
return(Ok(_mapper.Map <QueryResponse <AccountResponse> >(result)));
}
public async Task <List <AccountDto> > Handle(GetAccountsQuery request, CancellationToken cancellationToken)
{
return(await _context.Accounts
.ProjectTo <AccountDto>(_mapper.ConfigurationProvider)
.OrderBy(t => t.Name)
.ToListAsync(cancellationToken));
}
public async Task Then_The_Query_Is_Handled_And_Data_Returned(
GetAccountsQuery query,
List <GetUserAccountsResponse> apiResponse,
GetAccountTeamMembersResponse teamResponse,
[Frozen] Mock <IAccountsApiClient <AccountsConfiguration> > accountsApiClient,
GetAccountsQueryHandler handler)
{
teamResponse.UserRef = query.UserId;
accountsApiClient
.Setup(x => x.GetAll <GetUserAccountsResponse>(
It.Is <GetUserAccountsRequest>(c => c.GetAllUrl.Contains($"user/{query.UserId}/accounts"))))
.ReturnsAsync(apiResponse);
accountsApiClient
.Setup(x => x.GetAll <GetAccountTeamMembersResponse>(
It.Is <GetAccountTeamMembersRequest>(c => c.GetAllUrl.Contains($"accounts/{apiResponse.First().EncodedAccountId}/users"))))
.ReturnsAsync(new List <GetAccountTeamMembersResponse> {
teamResponse
});
var actual = await handler.Handle(query, CancellationToken.None);
actual.UserAccountResponse.First().Role.Should().Be(teamResponse.Role);
actual.UserAccountResponse.First().DasAccountName.Should().Be(apiResponse.First().DasAccountName);
actual.UserAccountResponse.First().EncodedAccountId.Should().Be(apiResponse.First().EncodedAccountId);
}
public async Task <IEnumerable <Account> > Handle(GetAccountsQuery request, CancellationToken cancellationToken)
{
var accounts = await
_dbContext.Accounts.FromSqlRaw("SELECT * FROM dbo.Account a WHERE a.user_id = {0}", request.UserId)
.ToListAsync(cancellationToken);
return(accounts);
}
public async Task <List <Account> > Handle(GetAccountsQuery request, CancellationToken cancellationToken)
{
List <Account>?accounts = await contextAdapter.Context
.Accounts
.OrderByInclusion()
.OrderByName()
.ToListAsync(cancellationToken);
return(accounts);
}
public async Task <IActionResult> Index([FromQuery] GetAccountsQuery query)
{
var result = await _mediator.Send(query);
if (result?.Accounts == null || !result.Accounts.Any())
{
return(NoContent());
}
return(Ok(result));
}
public async Task <IActionResult> Get(int skip = 0, int take = 10)
{
var query = new GetAccountsQuery
{
UserId = CurrentUserId,
Skip = skip,
Take = take
};
return(Ok(await _mediator.Send(query)));
}
public Task <IReadOnlyList <Account> > Handle(GetAccountsQuery request, CancellationToken cancellationToken)
{
var list = _accountRepo.SelectAsync(p => new Account
{
Id = p.Id,
CreateTimeUtc = p.CreateTimeUtc,
LastLoginIp = p.LastLoginIp,
LastLoginTimeUtc = p.LastLoginTimeUtc,
Username = p.Username
});
return(list);
}
public async Task <IActionResult> GetAccountsForUser(string userId)
{
var query = new GetAccountsQuery(userId);
var accounts = await _mediator.Send(query);
if (accounts == null)
{
return(NotFound());
}
else
{
return(Ok(accounts));
}
}
public async Task ShouldReturnAllAccounts()
{
var query = new GetAccountsQuery();
var name1 = "test1";
var name2 = "test2";
await Fixture.AddAsync(new Account(name1, AccountType.Checking, 0, new Currency("test", "TST")));
await Fixture.AddAsync(new Account(name2, AccountType.Checking, 0, new Currency("test", "TST")));
var accountsVm = await Fixture.SendAsync(query);
accountsVm.Accounts.Should().HaveCount(2);
accountsVm.Accounts[0].Name.Should().Be(name1);
accountsVm.Accounts[1].Name.Should().Be(name2);
}
public async Task <IActionResult> GetAll(string query, int pageNumber = 1, int pageSize = 10, CancellationToken token = default(CancellationToken))
{
var accountsQuery = new GetAccountsQuery(pageNumber, pageSize)
{
Query = query
};
var accounts = await _queryProcessor.ExecuteAsync(accountsQuery, cancellationToken : token);
var args = new PageRendererArgs <AccountModel>
{
Page = accounts,
RouteArguments = new PagedRouteArgs {
PageNumber = pageNumber, PageSize = pageSize, Query = query
},
};
return(new OkObjectResult(_accountRenderer.Render(args)));
}
public async Task <List <Account> > Handle(GetAccountsQuery request, CancellationToken cancellationToken)
{
return(await _table.GetListAsync(request.UserId));
}
public async Task <List <Account> > Handle(GetAccountsQuery request, CancellationToken cancellationToken)
{
return(await _accountRepository.GetAsync());
}
public Task <IEnumerable <Account> > Handle(GetAccountsQuery request, CancellationToken cancellationToken)
{
return(getAccounts.GetAccounts());
}
public async Task <List <Account> > Handle(GetAccountsQuery request, CancellationToken cancellationToken)
{
return(await context.Accounts.OrderByName().ToListAsync(cancellationToken));
}
public async Task <IEnumerable <AccountDto> > Handle(GetAccountsQuery request)
{
IEnumerable <Account> accounts = await persistence.GetAllAccounts();
return(accounts.Select(x => AccountDto.From(x)));
}
public async Task <ActionResult <GetAccountsResult> > GetAccountsWithPagination([FromQuery] GetAccountsQuery query)
{
return(await Mediator.Send(query));
}
