public async Task <IActionResult> RedeemVoucher([FromQuery] String voucherCode,
[FromQuery] String applicationVersion,
CancellationToken cancellationToken)
{
if (ClaimsHelper.IsPasswordToken(this.User) == false)
{
return(this.Forbid());
}
// Do the software version check
try
{
VersionCheckRequest versionCheckRequest = VersionCheckRequest.Create(applicationVersion);
await this.Mediator.Send(versionCheckRequest, cancellationToken);
}
catch (VersionIncompatibleException vex)
{
Logger.LogError(vex);
return(this.StatusCode(505));
}
Guid estateId = Guid.Parse(ClaimsHelper.GetUserClaim(this.User, "estateId").Value);
Guid contractId = Guid.Parse(ClaimsHelper.GetUserClaim(this.User, "contractId").Value);
// Now do the GET
RedeemVoucherRequest request = RedeemVoucherRequest.Create(estateId, contractId, voucherCode);
RedeemVoucherResponse response = await this.Mediator.Send(request, cancellationToken);
return(this.Ok(this.ModelFactory.ConvertFrom(response)));
}
public void ModelFactory_ConvertFrom_RedeemVoucherResponse_NullValue_IsConverted()
{
ModelFactory modelFactory = new ModelFactory();
RedeemVoucherResponse model = null;
RedeemVoucherResponseMessage dto = modelFactory.ConvertFrom(model);
dto.ShouldBeNull();
}
public void ModelFactory_ConvertFrom_RedeemVoucherResponse_IsConverted()
{
ModelFactory modelFactory = new ModelFactory();
RedeemVoucherResponse model = TestData.RedeemVoucherResponse;
DataTransferObjects.RedeemVoucherResponse dto = modelFactory.ConvertFrom(model);
dto.ShouldNotBeNull();
dto.ExpiryDate.ShouldBe(model.ExpiryDate);
dto.VoucherCode.ShouldBe(model.VoucherCode);
dto.RemainingBalance.ShouldBe(model.RemainingBalance);
}
public void ModelFactory_ConvertFrom_RedeemVoucherResponse_IsConverted()
{
ModelFactory modelFactory = new ModelFactory();
RedeemVoucherResponse model = TestData.RedeemVoucherResponseModel;
RedeemVoucherResponseMessage dto = modelFactory.ConvertFrom(model);
dto.ShouldNotBeNull();
dto.ContractId.ShouldBe(model.ContractId);
dto.VoucherCode.ShouldBe(model.VoucherCode);
dto.EstateId.ShouldBe(model.EstateId);
dto.Balance.ShouldBe(model.Balance);
dto.ExpiryDate.ShouldBe(model.ExpiryDate);
dto.ResponseMessage.ShouldBe(model.ResponseMessage);
dto.ResponseCode.ShouldBe(model.ResponseCode);
}
public async Task WhenIRedeemTheVoucherForTransactionIdTheVoucherBalanceWillBe(Guid transactionId, Decimal balance)
{
(IssueVoucherRequest request, IssueVoucherResponse response)voucher = this.TestingContext.GetVoucherByTransactionId(transactionId);
RedeemVoucherRequest redeemVoucherRequest = new RedeemVoucherRequest
{
EstateId = voucher.request.EstateId,
RedeemedDateTime = DateTime.Now,
VoucherCode = voucher.response.VoucherCode
};
// Do the redeem
await Retry.For(async() =>
{
RedeemVoucherResponse response = await this.TestingContext.DockerHelper.VoucherManagementClient
.RedeemVoucher(this.TestingContext.AccessToken, redeemVoucherRequest, CancellationToken.None)
.ConfigureAwait(false);
response.RemainingBalance.ShouldBe(balance);
});
}
public async Task VoucherDomainService_RedeemVoucher_VoucherIssued()
{
IConfigurationRoot configurationRoot = new ConfigurationBuilder().AddInMemoryCollection(TestData.DefaultAppSettings).Build();
ConfigurationReader.Initialise(configurationRoot);
Logger.Initialise(NullLogger.Instance);
Mock <IEstateClient> estateClient = new Mock <IEstateClient>();
Mock <ISecurityServiceClient> securityServiceClient = new Mock <ISecurityServiceClient>();
Mock <IAggregateRepository <VoucherAggregate, DomainEventRecord.DomainEvent> > voucherAggregateRepository = new Mock <IAggregateRepository <VoucherAggregate, DomainEventRecord.DomainEvent> >();
voucherAggregateRepository.Setup(v => v.GetLatestVersion(It.IsAny <Guid>(), It.IsAny <CancellationToken>())).ReturnsAsync(TestData.GetVoucherAggregateWithRecipientMobile);
securityServiceClient.Setup(s => s.GetToken(It.IsAny <String>(), It.IsAny <String>(), It.IsAny <CancellationToken>())).ReturnsAsync(TestData.TokenResponse);
estateClient.Setup(e => e.GetEstate(It.IsAny <String>(), It.IsAny <Guid>(), It.IsAny <CancellationToken>())).ReturnsAsync(TestData.GetEstateResponseWithOperator1);
EstateReportingGenericContext context = await this.GetContext(Guid.NewGuid().ToString("N"), TestDatabaseType.InMemory);
context.Vouchers.Add(new Voucher
{
VoucherCode = TestData.VoucherCode,
EstateId = TestData.EstateId
});
await context.SaveChangesAsync();
var dbContextFactory = this.GetMockDbContextFactory();
dbContextFactory.Setup(d => d.GetContext(It.IsAny <Guid>(), It.IsAny <CancellationToken>())).ReturnsAsync(context);
VoucherDomainService domainService = new VoucherDomainService(voucherAggregateRepository.Object,
securityServiceClient.Object,
estateClient.Object,
dbContextFactory.Object);
RedeemVoucherResponse redeemVoucherResponse = await domainService.RedeemVoucher(TestData.EstateId,
TestData.VoucherCode,
TestData.RedeemedDateTime,
CancellationToken.None);
redeemVoucherResponse.ShouldNotBeNull();
}
/// <summary>
/// Converts from.
/// </summary>
/// <param name="model">The model.</param>
/// <returns></returns>
public RedeemVoucherResponseMessage ConvertFrom(RedeemVoucherResponse model)
{
if (model == null)
{
return(null);
}
RedeemVoucherResponseMessage responseMessage = new RedeemVoucherResponseMessage
{
VoucherCode = model.VoucherCode,
Balance = model.Balance,
ResponseMessage = model.ResponseMessage,
ContractId = model.ContractId,
EstateId = model.EstateId,
ExpiryDate = model.ExpiryDate,
ResponseCode = model.ResponseCode
};
return(responseMessage);
}
/// <summary>
/// Redeems the voucher.
/// </summary>
/// <param name="accessToken">The access token.</param>
/// <param name="redeemVoucherRequest">The redeem voucher request.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns></returns>
public async Task <RedeemVoucherResponse> RedeemVoucher(String accessToken,
RedeemVoucherRequest redeemVoucherRequest,
CancellationToken cancellationToken)
{
RedeemVoucherResponse response = null;
String requestUri = $"{this.BaseAddress}/api/vouchers";
try
{
String requestSerialised = JsonConvert.SerializeObject(redeemVoucherRequest);
StringContent httpContent = new StringContent(requestSerialised, Encoding.UTF8, "application/json");
// Add the access token to the client headers
this.HttpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
// Make the Http Call here
HttpResponseMessage httpResponse = await this.HttpClient.PutAsync(requestUri, httpContent, cancellationToken);
// Process the response
String content = await this.HandleResponse(httpResponse, cancellationToken);
// call was successful so now deserialise the body to the response object
response = JsonConvert.DeserializeObject <RedeemVoucherResponse>(content);
}
catch (Exception ex)
{
// An exception has occurred, add some additional information to the message
Exception exception = new Exception("Error redeeming voucher.", ex);
throw exception;
}
return(response);
}
