public JsonResult OrderDelete(DraftOrder order)
{
try
{
if (ModelState.IsValid)
{
ShopifyAPIClient api = new ShopifyAPIClient(authState);
// Del from shopify store
api.Delete("/admin/orders/" + order.Id + ".json");
// Del from db
repositories.OrderRepository.RemoveById(order.Id);
// Find by id product for delete
var AllOrders = ((List <DraftOrder>)(CacheManager.List as ArrayList)[1]);
var ordcache = AllOrders.Where(p => p.Id == order.Id).FirstOrDefault();
//Remove from cache
((List <DraftOrder>)(CacheManager.List as ArrayList)[1]).Remove(ordcache);
return(Json(new { success = "removed" }, JsonRequestBehavior.AllowGet));
}
else
{
return(Json(new { error = "Model is not valid" }, JsonRequestBehavior.AllowGet));
}
}
catch (System.Exception e)
{
return(Json(new { error = e.Message }, JsonRequestBehavior.AllowGet));
}
}
private bool WasNotAlreadyHandled(DraftOrder draftOrder, int eventVersion)
{
// This assumes that events will be handled in order, but we might get the same message more than once.
if (eventVersion > draftOrder.OrderVersion)
{
return(true);
}
else if (eventVersion == draftOrder.OrderVersion)
{
logger.LogWarning(
"Ignoring duplicate draft order update message with version {1} for order id {0}",
draftOrder.OrderID,
eventVersion);
return(false);
}
else
{
logger.LogWarning(
@"An older order update message was received with with version {1} for order id {0}, last known version {2}.
This read model generator has an expectation that the EventBus will deliver messages for the same source in order.",
draftOrder.OrderID,
eventVersion,
draftOrder.OrderVersion);
return(false);
}
}
public void Handle(OrderPlaced @event)
{
var dto = new DraftOrder(@event.SourceId, @event.ConferenceId, (int)DraftOrder.States.PendingReservation, @event.Version)
{
AccessCode = @event.AccessCode,
};
dto.Lines.AddRange(@event.Seats.Select(seat => new DraftOrderItem(seat.SeatType, seat.Quantity)));
draftOrderRepository.Insert(dto);
}
public async Task Consume(ConsumeContext <OrderPlaced> consumeContext)
{
await using var repository = this.contextFactory.Invoke();
var dto = new DraftOrder(consumeContext.Message.SourceId, consumeContext.Message.ConferenceId, DraftOrder.States.PendingReservation, consumeContext.Message.Version)
{
AccessCode = consumeContext.Message.AccessCode,
};
dto.Lines.AddRange(consumeContext.Message.Seats.Select(seat => new DraftOrderItem(seat.SeatType, seat.Quantity)));
await repository.Save(dto);
}
public void Handle(OrderPlaced @event)
{
using (var context = contextFactory.Invoke()) {
var dto = new DraftOrder(@event.SourceId, @event.ConferenceId, DraftOrder.States.PendingReservation, @event.Version)
{
AccessCode = @event.AccessCode
};
dto.Lines.AddRange(@event.Seats.Select(seat => new DraftOrderItem(seat.SeatType, seat.Quantity)));
context.Save(dto);
}
}
private void UpdateViewModel(OrderViewModel viewModel, DraftOrder order)
{
viewModel.OrderId = order.OrderId;
viewModel.OrderVersion = order.OrderVersion;
viewModel.ReservationExpirationDate = order.ReservationExpirationDate.ToEpochMilliseconds();
foreach (var line in order.Lines)
{
var seat = viewModel.Items.First(s => s.SeatType.Id == line.SeatType);
seat.OrderItem = line;
seat.AvailableQuantityForOrder = seat.AvailableQuantityForOrder + line.RequestedSeats;
seat.MaxSelectionQuantity = Math.Min(seat.AvailableQuantityForOrder, 20);
seat.PartiallyFulfilled = line.RequestedSeats > line.ReservedSeats;
}
}
public void Handle(OrderPlaced @event)
{
using (var context = factory.Create())
{
var dto = new DraftOrder(@event.SourceId, @event.WorkshopId, DraftOrder.States.PendingReservation, @event.Version)
{
AccessCode = @event.AccessCode,
};
dto.Lines.AddRange(@event.Anchors.Select(anchor => new DraftOrderItem(anchor.AnchorType, anchor.Quantity)));
DbContext.Save(dto);
context.SaveChanges();
}
}
private static void UpdateViewModel(OrderViewModel viewModel, DraftOrder order)
{
viewModel.OrderId = order.OrderID;
viewModel.OrderVersion = order.OrderVersion;
viewModel.ReservationExpirationDate = order.ReservationExpirationDate.ToEpochMilliseconds();
// TODO check DTO matches view model
foreach (var line in order.Lines)
{
var seat = viewModel.Items.First(s => s.AnchorType.ID == line.AnchorType);
seat.OrderItem = line;
seat.AvailableQuantityForOrder = seat.AvailableQuantityForOrder + line.ReservedAnchors;
seat.MaxSelectionQuantity = Math.Min(seat.AvailableQuantityForOrder, 20);
seat.PartiallyFulfilled = line.RequestedAnchors > line.ReservedAnchors;
}
}
public void ThenTheOrderShouldBeCreatedWithTheFollowingOrderItems(Table table)
{
draftOrder = RegistrationHelper.GetModel <DraftOrder>(registrationController.ThankYou(registrationViewModel.Order.OrderId));
Assert.NotNull(draftOrder);
foreach (var row in table.Rows)
{
var orderItem = draftOrder.Lines.FirstOrDefault(
l => l.SeatType == conferenceInfo.Seats.First(s => s.Description == row["seat type"]).Id);
Assert.NotNull(orderItem);
Assert.Equal(Int32.Parse(row["quantity"]), orderItem.ReservedSeats);
}
// Wait for event processing
Thread.Sleep(Constants.WaitTimeout);
}
private static bool WasNotAlreadyHandled(DraftOrder draftOrder, int eventVersion)
{
if (eventVersion > draftOrder.OrderVersion)
{
return(true);
}
else if (eventVersion == draftOrder.OrderVersion)
{
Trace.TraceWarning("Ignoring duplicate draft order update message with version {1} for order id {0}",
draftOrder.OrderId, eventVersion);
return(false);
}
else
{
Trace.TraceWarning(
@"An older order update message was received with with version {1} for order id {0}, last known version {2}.
This read model generator has an expectation that the EventBus will deliver messages for the same source in order.",
draftOrder.OrderId,
eventVersion,
draftOrder.OrderVersion);
return(false);
}
}
public void when_specifying_registrant_and_credit_card_payment_details_for_a_valid_registration_then_sends_commands_and_redirects_to_payment_action()
{
var orderId = Guid.NewGuid();
var command = new AssignRegistrantDetails
{
OrderId = orderId,
Email = "*****@*****.**",
FirstName = "First Name",
LastName = "Last Name",
};
InitiateThirdPartyProcessorPayment paymentCommand = null;
// Arrange
var seatId = Guid.NewGuid();
var order = new DraftOrder(orderId, conferenceAlias.Id, DraftOrder.States.ReservationCompleted, 10);
order.Lines.Add(new DraftOrderItem(seatId, 5)
{
ReservedSeats = 5
});
Mock.Get <IOrderDao>(this.orderDao)
.Setup(d => d.FindDraftOrder(orderId))
.Returns(order);
Mock.Get <IOrderDao>(this.orderDao)
.Setup(d => d.FindPricedOrder(orderId))
.Returns(new PricedOrder {
OrderId = orderId, Total = 100, OrderVersion = 10
});
Mock.Get <ICommandBus>(this.bus)
.Setup(b => b.Send(It.IsAny <Envelope <ICommand> >()))
.Callback <Envelope <ICommand> >(
es => { if (es.Body is InitiateThirdPartyProcessorPayment)
{
paymentCommand = (InitiateThirdPartyProcessorPayment)es.Body;
}
});
this.routes.MapRoute("ThankYou", "thankyou", new { controller = "Registration", action = "ThankYou" });
this.routes.MapRoute("SpecifyRegistrantAndPaymentDetails", "checkout", new { controller = "Registration", action = "SpecifyRegistrantAndPaymentDetails" });
// Act
var result =
(RedirectToRouteResult)this.sut.SpecifyRegistrantAndPaymentDetails(command, RegistrationController.ThirdPartyProcessorPayment, 0).Result;
// Assert
Mock.Get <ICommandBus>(this.bus)
.Verify(b => b.Send(It.Is <Envelope <ICommand> >(es => es.Body == command)), Times.Once());
Assert.NotNull(paymentCommand);
Assert.Equal(conferenceAlias.Id, paymentCommand.ConferenceId);
Assert.Equal(orderId, paymentCommand.PaymentSourceId);
Assert.InRange(paymentCommand.TotalAmount, 99.9m, 100.1m);
Assert.Equal("Payment", result.RouteValues["controller"]);
Assert.Equal("ThirdPartyProcessorPayment", result.RouteValues["action"]);
Assert.Equal(this.conferenceAlias.Code, result.RouteValues["conferenceCode"]);
Assert.Equal(paymentCommand.PaymentId, result.RouteValues["paymentId"]);
Assert.True(((string)result.RouteValues["paymentAcceptedUrl"]).StartsWith("/thankyou"));
Assert.True(((string)result.RouteValues["paymentRejectedUrl"]).StartsWith("/checkout"));
}
