public async Task <IActionResult> Payment(ShoppingCartVM shoppingcart)
{
var reservationsFromCart = shoppingcart.Reservations;
var subscriptionsFromCart = shoppingcart.Subscriptions;
string userID = User.FindFirst(ClaimTypes.NameIdentifier).Value;
if (reservationsFromCart != null && reservationsFromCart.Count != 0)
{
var validations = await IsValidReservations(userID, reservationsFromCart);
if (!validations[0])
{
ModelState.AddModelError("error", "U kunt maar 10 tickets per match kopen.");
return(View("Index", shoppingcart));
}
if (!validations[1])
{
ModelState.AddModelError("error", "U kunt geen 2 verschillende matchen op dezelfde dag kopen.");
return(View("Index", shoppingcart));
}
if (!validations[2])
{
ModelState.AddModelError("error", "Uw aantal tickets overschrijdt het aantal beschikbare plaatsen.");
return(View("Index", shoppingcart));
}
List <Reservation> reservations = _mapper.Map <List <Reservation> >(reservationsFromCart);
for (var i = 0; i < reservationsFromCart.Count; i++)
{
reservations[i].CustomerId = userID;
shoppingcart.Reservations[i].Price = shoppingcart.Reservations[i].Price * shoppingcart.Reservations[i].NumberOfTickets;
reservations[i].Price = shoppingcart.Reservations[i].Price;
await _reservationService.CreateAsync(reservations[i]);
}
}
if (subscriptionsFromCart != null && subscriptionsFromCart.Count != 0)
{
List <Subscription> subscriptions = _mapper.Map <List <Subscription> >(subscriptionsFromCart);
foreach (var sub in subscriptions)
{
sub.CustomerId = userID;
await _subscriptionService.CreateAsync(sub);
}
}
var user = await _userManager.FindByIdAsync(userID);
var useremail = user.Email;
var customer = await _customerService.GetAsync(userID);
await _emailSender.SendEmailAsync(
useremail,
"Betaling Ontvangen",
BuildVoucherMessage(shoppingcart, customer.LastName + " " + customer.FirstName)
);
HttpContext.Session.SetObject("ShoppingCart", null);
return(View(shoppingcart));
}
public void GivenCreateAsyncWhenExpectedExceptionIsThrownThenHandlesGracefully()
{
// Arrange
// Act
var exception = Assert.ThrowsAsync <NotImplementedException>(
() => subscriptionService.CreateAsync(It.IsAny <Subscription>()));
// Assert
exception.Should().NotBeNull().And.BeOfType <NotImplementedException>();
}
public void GivenCreateAsyncWhenExpectedExceptionIsThrownThenHandlesGracefully()
{
// Arrange
// Act
var exception = Assert.ThrowsAsync <NotImplementedException>(
() => subscriptionService.CreateAsync(It.IsAny <Subscription>()));
// Assert
Assert.That(exception, Is.Not.Null);
Assert.That(exception, Is.TypeOf <NotImplementedException>());
}
internal async Task GivenCreateAsyncWhenExpectedExceptionIsThrownThenHandlesGracefully()
{
// Arrange
// Act
var exception = await Assert.ThrowsAsync <NotImplementedException>(
() => subscriptionService.CreateAsync(It.IsAny <Subscription>()));
// Assert
Assert.NotNull(exception);
Assert.IsType <NotImplementedException>(exception);
}
public async Task <IActionResult> CreateAsync([FromBody] Subscription subscription)
{
try
{
await subscriptionService.CreateAsync(subscription);
return(Created($"api/v1/subscriptions/{ subscription?.Id }", subscription));
}
catch
{
return(BadRequest());
}
}
public async Task <IActionResult> PostAsync([Required] CreateSubscriptionRequestDto request, [Required][FromHeader(Name = "User-Id")] string userId)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.Values));
}
var response = await _subscriptionService.CreateAsync(request, userId);
response.Url = GetUrl(response.SubscriptionId);
response.UserId = userId;
return(Ok(response));
}
public async Task <ActionResult> CreateOrUpdateAsync(Guid subscriptionId, [FromBody] Subscription subscription)
{
if (subscription == null)
{
throw new LunaBadRequestUserException(LoggingUtils.ComposePayloadNotProvidedErrorMessage(nameof(subscription)), UserErrorCode.PayloadNotProvided);
}
if (!subscriptionId.Equals(subscription.SubscriptionId))
{
throw new LunaBadRequestUserException(LoggingUtils.ComposeNameMismatchErrorMessage(typeof(Subscription).Name),
UserErrorCode.NameMismatch);
}
if (await _subscriptionService.ExistsAsync(subscriptionId))
{
_logger.LogInformation($"Update subscription {subscriptionId} with payload {JsonSerializer.Serialize(subscription)}.");
var sub = await _subscriptionService.GetAsync(subscriptionId);
AADAuthHelper.VerifyUserAccess(this.HttpContext, _logger, false, sub.Owner);
if (!sub.OfferName.Equals(subscription.OfferName, StringComparison.InvariantCultureIgnoreCase))
{
throw new LunaBadRequestUserException("Offer name of an existing subscription can not be changed.", UserErrorCode.InvalidParameter);
}
if (!string.IsNullOrEmpty(subscription.Owner) && !sub.Owner.Equals(subscription.Owner, StringComparison.InvariantCultureIgnoreCase))
{
throw new LunaBadRequestUserException("Owner name of an existing subscription can not be changed.", UserErrorCode.InvalidParameter);
}
if (sub.PlanName.Equals(subscription.PlanName, StringComparison.InvariantCultureIgnoreCase))
{
throw new LunaConflictUserException($"The subscription {subscription.SubscriptionId} is already in plan {subscription.PlanName}.");
}
// Update existing subscription
await _fulfillmentManager.RequestUpdateSubscriptionAsync(subscriptionId, subscription.PlanName);
return(Ok(await _subscriptionService.GetAsync(subscriptionId)));
}
else
{
_logger.LogInformation($"Create subscription {subscriptionId} with payload {JsonSerializer.Serialize(subscription)}.");
// Create a new subscription
AADAuthHelper.VerifyUserAccess(this.HttpContext, _logger, false, subscription.Owner);
await _subscriptionService.CreateAsync(subscription);
return(CreatedAtRoute(nameof(GetAsync) + nameof(Subscription), new { subscriptionId = subscription.SubscriptionId }, subscription));
}
}