public async Task MapsPagingProperties()
{
// given
var subject = new PaymentsClient(_clientConfiguration);
var firstPageRequest = new GetPaymentsRequest
{
Limit = 1
};
// when
var firstPageResult = await subject.GetPageAsync(firstPageRequest);
var secondPageRequest = new GetPaymentsRequest
{
After = firstPageResult.Meta.Cursors.After,
Limit = 2
};
var secondPageResult = await subject.GetPageAsync(secondPageRequest);
// then
Assert.That(firstPageResult.Items.Count(), Is.EqualTo(firstPageRequest.Limit));
Assert.That(firstPageResult.Meta.Limit, Is.EqualTo(firstPageRequest.Limit));
Assert.That(firstPageResult.Meta.Cursors.Before, Is.Null);
Assert.That(firstPageResult.Meta.Cursors.After, Is.Not.Null);
Assert.That(secondPageResult.Items.Count(), Is.EqualTo(secondPageRequest.Limit));
Assert.That(secondPageResult.Meta.Limit, Is.EqualTo(secondPageRequest.Limit));
Assert.That(secondPageResult.Meta.Cursors.Before, Is.Not.Null);
Assert.That(secondPageResult.Meta.Cursors.After, Is.Not.Null);
}
public async Task <IActionResult> Get(long sinumber, [FromQuery] string insz)
{
var certificates = await _thabcertificateService.SearchAsync(new ThabCertificateSearch { SiNumber = sinumber, Insz = insz });
List <ThabPayment> payments = new List <ThabPayment>();
foreach (var cert in certificates)
{
var request = new GetPaymentsRequest()
{
SiNumber = sinumber,
ReferenceDate = cert.ReferenceDate
};
var response = await _service.GetPaymentsAsync(request);
if (response.BusinessMessages != null && response.BusinessMessages.Length > 0)
{
return(BadRequest(response.BusinessMessages));
}
var mappedModels = _mapper.Map <IEnumerable <ThabPayment> >(response?.Value?.Payments, opt => opt.Items["Id"] = cert.CertificateId);
payments.AddRange(mappedModels);
}
return(Ok(payments));
}
public async Task <IActionResult> Get()
{
var request = new GetPaymentsRequest();
var payments = await mediator.Send(request);
return(Ok(payments));
}
public override Task <GetPaymentsResult> GetByAccounts(GetPaymentsRequest request, ServerCallContext context)
{
var payments = paymentsRepository.GetByAccounts(request.Ids)
.Select(p => mapper.Map <Payment>(p))
.ToArray();
return(Task.FromResult(new GetPaymentsResult {
Payments = { payments }
}));
}
public IEnumerable <GetPaymentsResponse> GetPayments([FromQuery] GetPaymentsRequest request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
return(QueryProcessor.Execute(
new GetPaymentsQuery(request.Month, request.Year, request.PaymentTypeId,
request.Amount?.Exact, request.Amount?.Min, request.Amount?.Max)));
}
public override Task <GetPaymentsResult> Get(GetPaymentsRequest request, ServerCallContext context)
{
var payments = request.Ids.Select(id => paymentsRepository.Get(id))
.Where(payment => payment != null)
.Select(p => mapper.Map <Payment>(p))
.ToArray();
return(Task.FromResult(new GetPaymentsResult {
Payments = { payments }
}));
}
public async Task <PaymentsAndLoans> GetPaymentsWithLoans(Metadata headers, string[] accountsIds)
{
var request = new GetPaymentsRequest {
Ids = { accountsIds }
};
var response = await paymentsClient.GetByAccountsAsync(request, headers);
return(new PaymentsAndLoans
{
Loans = response.Loans.ToArray(),
Payments = response.Payments.ToArray()
});
}
public Task <Result <GetPaymentsResponse> > Handle(GetPaymentsRequest request, CancellationToken cancellationToken)
{
var notDisabled = new NotDisabledSpecification();
var payments = _paymentRepository.LoadWhere(notDisabled);
return(Result <GetPaymentsResponse>
.SuccessTask(new GetPaymentsResponse
{
Data = payments?.Select(x => new PaymentItem
{
Id = x.Id,
Name = x.Name
}).ToList().AsReadOnly() ?? new List <PaymentItem>().AsReadOnly()
}));
}
public void GetPaymentsRequestIsNullThrows()
{
// given
var subject = new PaymentsClient(_clientConfiguration);
GetPaymentsRequest request = null;
// when
AsyncTestDelegate test = () => subject.GetPageAsync(request);
// then
var ex = Assert.ThrowsAsync <ArgumentNullException>(test);
Assert.That(ex.ParamName, Is.EqualTo(nameof(request)));
}
public async Task CallsGetPaymentsEndpointUsingRequest()
{
// given
var subject = new PaymentsClient(_clientConfiguration);
var request = new GetPaymentsRequest
{
Before = "before test",
After = "after test",
Limit = 5
};
// when
await subject.GetPageAsync(request);
// then
_httpTest
.ShouldHaveCalled("https://api.gocardless.com/payments?before=before%20test&after=after%20test&limit=5")
.WithVerb(HttpMethod.Get);
}
private async Task <decimal> GetCurrentPaymentAmount(long siNumber, DateTime reference)
{
var request = new GetPaymentsRequest()
{
SiNumber = siNumber, ReferenceDate = reference
};
var response = await _thabService.GetPaymentsAsync(request);
if (response.Value != null && response.Value.Payments != null && response.Value.Payments.Count() > 0)
{
return(response.Value.Payments.OrderByDescending(p => p.PeriodEnd).FirstOrDefault().Amount);
}
else if (response.BusinessMessages != null && response.BusinessMessages.Any())
{
var errors = response.BusinessMessages.Where(bm => bm.Type == MessageType.Error);
if (errors.Any())
{
throw new Exception(string.Join("; ", errors.Select(e => e.MessageString)));
}
}
return(0);
}
public async Task PagesThroughPayments()
{
// given
var subject = new PaymentsClient(_clientConfiguration);
var firstId = (await subject.GetPageAsync()).Items.First().Id;
var initialRequest = new GetPaymentsRequest
{
After = firstId,
CreatedGreaterThan = new DateTimeOffset(DateTime.Now.AddDays(-1)),
Limit = 1,
};
// when
var result = await subject
.BuildPager()
.StartFrom(initialRequest)
.AndGetAllAfterAsync();
// then
Assert.That(result.Count, Is.GreaterThan(1));
Assert.That(result[0].Id, Is.Not.Null.And.Not.EqualTo(result[1].Id));
Assert.That(result[1].Id, Is.Not.Null.And.Not.EqualTo(result[0].Id));
}
/// <remarks/>
public void GetPaymentsAsync(GetPaymentsRequest GetPaymentsRequest, object userState) {
if ((this.GetPaymentsOperationCompleted == null)) {
this.GetPaymentsOperationCompleted = new System.Threading.SendOrPostCallback(this.OnGetPaymentsOperationCompleted);
}
this.InvokeAsync("GetPayments", new object[] {
GetPaymentsRequest}, this.GetPaymentsOperationCompleted, userState);
}
/// <remarks/>
public void GetPaymentsAsync(GetPaymentsRequest GetPaymentsRequest) {
this.GetPaymentsAsync(GetPaymentsRequest, null);
}
/// <inheritdoc />
public async Task <List <PaymentDto> > Handle(GetPaymentsRequest request, CancellationToken cancellationToken)
{
return(await paymentsRepository.GetAllPayments(cancellationToken));
}
public override Task <GetPaymentsWithLoansResult> GetByAccounts(GetPaymentsRequest request, ServerCallContext context)
{
var payments = paymentsRepository.GetByAccounts(request.Ids);
return(WithLoans(payments, context.RequestHeaders.SelectCustom()));
}
