public async Task <IHttpActionResult> Get()
{
var request = new GetAccountsRequest();
request.TenantUniqueId = Request.GetTenantUniqueId();
return(Ok(await _mediator.Send(request)));
}
public async Task Should_Get_Accounts_Collection_When_Requesting_By_Administrator_Client()
{
var accountEntity = await InsertAccountEntityAsync(_fixture.AdministratorDbContext);
var getAccountsRequest = new GetAccountsRequest
{
Email = accountEntity.Email,
Confirmed = accountEntity.Confirmed,
Sort = "email:asc",
PageSize = 100,
Page = 1
};
_fixture.AdministratorHttpClient.DefaultRequestHeaders.Add("api-version", "1");
var expectedResponse = await PrepareExpectedResponseAsync(getAccountsRequest, _fixture.AdministratorDbContext);
var response =
await _fixture.AdministratorHttpClient.GetAsync(
$"api/accounts?page={getAccountsRequest.Page}&pageSize={getAccountsRequest.PageSize}&sort={getAccountsRequest.Sort}&email={getAccountsRequest.Email}&confirmed={getAccountsRequest.Confirmed}");
var responseContentString = await response.Content.ReadAsStringAsync();
response.StatusCode.Should().BeEquivalentTo(HttpStatusCode.OK);
responseContentString.Should().BeEquivalentTo(expectedResponse);
}
public async Task <IHttpActionResult> Get()
{
var request = new GetAccountsRequest();
request.TenantId = (await _userManager.GetUserAsync(User)).TenantId;
return(Ok(await _mediator.Send(request)));
}
private static async Task <string> PrepareExpectedResponseAsync(GetAccountsRequest getAccountsRequest, RivaIdentityDbContext context)
{
var accountEntities = await context.Accounts
.Where(x => x.Email.ToLower().StartsWith(getAccountsRequest.Email.ToLower()) && x.Confirmed == getAccountsRequest.Confirmed)
.OrderBy(x => x.Email)
.Skip(getAccountsRequest.PageSize.Value * (getAccountsRequest.Page.Value - 1))
.Take(getAccountsRequest.PageSize.Value)
.ToListAsync();
var totalCount = await context.Accounts
.LongCountAsync(x => x.Email.ToLower().StartsWith(getAccountsRequest.Email.ToLower()) && x.Confirmed == getAccountsRequest.Confirmed);
var getAccountsCollectionItemResponses = accountEntities.Select(x =>
new GetAccountsCollectionItemResponse(x.Id, x.Email, x.Confirmed, x.Created,
!string.IsNullOrWhiteSpace(x.PasswordHash), x.LastLogin));
var collectionResponse = new CollectionResponse <GetAccountsCollectionItemResponse>(totalCount, getAccountsCollectionItemResponses);
var settings = new JsonSerializerSettings
{
Formatting = Formatting.Indented,
ContractResolver = new DefaultTestPlatformContractResolver
{
NamingStrategy = new CamelCaseNamingStrategy()
},
Converters = new List <JsonConverter> {
new StringEnumConverter()
}
};
return(JsonConvert.SerializeObject(collectionResponse, settings));
}
public GetAccountsResponse GetAccounts(GetAccountsRequest request, IAuthContext authContext)
{
var accountRepo = _unitOfWork.GetRepository <Account>();
var accounts = accountRepo.GetAsyncQueryable(x => x.UserId.ToString() == authContext.UserId, w => w.AccountIdentifications).Result.ToList();
GetAccountsResponse response = new GetAccountsResponse();
response.Items = new List <GetAccountsResponseItem>();
foreach (Account acc in accounts)
{
var account = new GetAccountsResponseItem()
{
AccountId = acc.Id.ToString(),
AccountType = AccountType.GetInstance(acc.AccountType).Text,
CurrencyType = CurrencyType.GetInstance(acc.CurrencyType).Text,
Name = acc.Name,
ProviderAccountId = acc.ProviderAccountId,
ProviderName = Provider.GetInstance(acc.ProviderId).Text
};
foreach (AccountIdentification ai in acc.AccountIdentifications)
{
account.AccountIdentification.Add(AccountIdentificationType.GetInstance(ai.AccountIdentificationTypeId).Text + ": " + ai.Identification);
}
response.Items.Add(account);
}
return(response);
}
public void GetAccounts()
{
MainWindow main = App.Current.MainWindow as MainWindow;
GetAccountsRequest request = new GetAccountsRequest(main.Client.Serializer);
JamPacket requestPacket = new JamPacket(Guid.Empty, Guid.Empty, GetAccountsRequest.DATA_TYPE, request.GetBytes());
main.Client.Send(requestPacket);
}
public async Task <IActionResult> GetAccountsAsync([FromQuery] GetAccountsRequest request)
{
var getAccountsInputQuery = _mapper.Map <GetAccountsRequest, GetAccountsInputQuery>(request);
var collectionOutputQuery = await _getAccountsQueryHandler.HandleAsync(getAccountsInputQuery);
var collectionResponse = _mapper.Map <CollectionOutputQuery <GetAccountsOutputQuery>, CollectionResponse <GetAccountsCollectionItemResponse> >(collectionOutputQuery);
return(Ok(collectionResponse));
}
public override Task <GetAccountsResponse> Get(GetAccountsRequest request, ServerCallContext context)
{
var accounts = request.Ids.Select(id => accountsRepository.Get(id))
.Where(account => account != null)
.Select(account => mapper.Map <Account>(account));
return(Task.FromResult(new GetAccountsResponse {
Accounts = { accounts }
}));
}
public async Task <List <AccountInfo> > GetAccounts(string username)
{
var id = NextValidId;
var request = new GetAccountsRequest
{
ID = id,
Username = username
};
return(await RequestHelper <List <AccountInfo> > .ProceedRequest(id, _client, request));
}
public async Task <List <AccountVm> > Handle(GetAccountsRequest request, CancellationToken cancellationToken)
{
var results = new List <AccountVm>();
var accounts = _context.Accounts
.Where(x => x.UserId == _identityService.UserId)
.OrderBy(x => x.Name)
.ToList();
foreach (Account account in accounts)
{
account.SetAccountType(AbstractEnumeration.FromValue <AccountType>(account.AccountTypeId));
account.SetInstitution(AbstractEnumeration.FromValue <Institution>(account.InstitutionId));
results.Add(_mapper.Map <AccountVm>(account));
}
return(await Task.Run(() => results.ToList(), cancellationToken));
}
public override Task <GetAccountsResponse> GetAccounts(GetAccountsRequest request, ServerCallContext context)
{
var res = new GetAccountsResponse();
res.Accounts.AddRange(
_accountsService.GetClientAccounts(request.ClientId).Select(a =>
new GetAccountsResponse.Types.Account
{
AccountId = a.AccountId,
Balance = DecimalValue.FromDecimal(a.Balance),
Number = a.Number,
Name = a.Name,
Description = a.Description,
OpenDate = Timestamp.FromDateTime(a.OpenDate.ToUniversalTime())
}
));
return(Task.FromResult(res));
}
public async Task GetAccountsAsync_Should_Return_OkObjectResult_With_CollectionResponse_With_GetAccountsCollectionItemResponses()
{
var getAccountsRequest = new GetAccountsRequest
{
Email = "*****@*****.**",
Confirmed = true,
Sort = "email:asc",
Page = 1,
PageSize = 100
};
var getAccountsInputQuery = new GetAccountsInputQuery(getAccountsRequest.Page, getAccountsRequest.PageSize,
getAccountsRequest.Sort, getAccountsRequest.Email, getAccountsRequest.Confirmed);
var getAccountsOutputQueries = new List <GetAccountsOutputQuery>
{
new GetAccountsOutputQuery(Guid.NewGuid(), getAccountsRequest.Email, getAccountsRequest.Confirmed.Value,
DateTimeOffset.UtcNow, true, null)
};
var collectionOutputQuery = new CollectionOutputQuery <GetAccountsOutputQuery>(getAccountsOutputQueries.Count, getAccountsOutputQueries);
var getAccountsCollectionItemResponses = getAccountsOutputQueries.Select(x =>
new GetAccountsCollectionItemResponse(x.Id, x.Email, x.Confirmed, x.Created, x.PasswordAssigned, x.LastLogin));
var collectionResponse = new CollectionResponse <GetAccountsCollectionItemResponse>(getAccountsOutputQueries.Count, getAccountsCollectionItemResponses);
_mapperMock.Setup(x => x.Map <GetAccountsRequest, GetAccountsInputQuery>(It.IsAny <GetAccountsRequest>()))
.Returns(getAccountsInputQuery);
_getAccountsQueryHandlerMock
.Setup(x => x.HandleAsync(It.IsAny <GetAccountsInputQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(collectionOutputQuery);
_mapperMock.Setup(x =>
x.Map <CollectionOutputQuery <GetAccountsOutputQuery>,
CollectionResponse <GetAccountsCollectionItemResponse> >(
It.IsAny <CollectionOutputQuery <GetAccountsOutputQuery> >())).Returns(collectionResponse);
var result = await _controller.GetAccountsAsync(getAccountsRequest);
var okResult = result.As <OkObjectResult>();
okResult.Value.Should().BeEquivalentTo(collectionResponse);
}
public GetAccountsResponse GetAccounts(GetAccountsRequest request)
{
return(Execute(() => InternalService.GetAccounts(request)));
}
public async Task <GetAccountsResponse> GetAccounts(GetAccountsRequest request)
{
return(await _levyTransferMatchingApiClient.Get <GetAccountsResponse>(request));
}
public Task <GetAccountsResponse> GetAccounts(GetAccountsRequest request, CancellationToken cts = default(CancellationToken))
{
return(SendCommandAsync <GetAccountsRequest, GetAccountsResponse>("get_accounts", request, cts));
}
public ActionResult <GetAccountsResponse> GetAccounts([FromQuery] GetAccountsRequest request)
{
GetAccountsResponse response = _accountDataService.GetAccounts(request, _authContext);
return(Ok(response));
}
public GetAccountsResponse GetAccounts(GetAccountsRequest request)
{
return(ExecuteAction <GetAccountsResponse>(request));
}
