// GET: Unity
public ActionResult Index()
{
string value = priceCalculator.CalculatePrice();
_logger.LogInfo("Price Added to the calculator");
return(View());
}
public BuyNow(IPriceCalculator calculator)
{
CompositeEvent(() => OrderWasReserved, x => x.OrderWarReservedStatus, OrderFinalized, StockReserved);
During(Initial,
When(PurchaseOrdered).Then((state, domainEvent) =>
{
state.AccountId = domainEvent.AccountId;
state.OrderId = domainEvent.OrderId;
state.Quantity = domainEvent.Quantity;
state.SkuId = domainEvent.SkuId;
state.UserId = domainEvent.SourceId;
state.StockId = domainEvent.StockId;
Dispatch(new CreateOrderCommand(state.OrderId, state.UserId));
}).TransitionTo(CreatingOrder));
During(CreatingOrder,
When(OrderCreated).ThenAsync(async(state, e) =>
{
var totalPrice =
await calculator.CalculatePrice(state.SkuId, state.Quantity);
Dispatch(new AddItemToOrderCommand(state.OrderId,
state.SkuId,
state.Quantity,
totalPrice));
}).TransitionTo(AddingOrderItems));
During(AddingOrderItems,
When(ItemAdded)
.Then((state, e) => { Dispatch(new ReserveStockCommand(state.StockId, state.UserId, state.Quantity)); })
.TransitionTo(Reserving));
During(Reserving,
When(StockReserved).Then((state, domainEvent) =>
{
state.ReserveId = domainEvent.ReserveId;
Dispatch(new CalculateOrderTotalCommand(state.OrderId));
}),
When(OrderFinalized)
.Then(
(state, domainEvent) => { Dispatch(new PayForOrderCommand(state.AccountId, domainEvent.TotalPrice, state.OrderId)); }),
When(OrderWasReserved).TransitionTo(Paying));
During(Paying,
When(OrderPaid, ctx => ctx.Data.ChangeId == ctx.Instance.OrderId)
.Then((state, e) => { Dispatch(new TakeReservedStockCommand(state.StockId, state.ReserveId)); })
.TransitionTo(TakingStock));
During(TakingStock,
When(ReserveTaken).Then((state, e) =>
{
Dispatch(new CompleteOrderCommand(state.OrderId));
Dispatch(new CompletePendingOrderCommand(state.UserId, state.OrderId));
}).Finalize());
}
public void CalculatePrices(DateTime now)
{
foreach (var cheese in Cheeses)
{
DecrementDaysToSell(cheese);
_priceCalculator.CalculatePrice(cheese, now);
}
_printer.Print(Cheeses, now);
}
public decimal TotalAmount()
{
decimal total = 0m;
foreach (OrderItem orderItem in OrderItems)
{
total += _priceCalculator.CalculatePrice(orderItem);
}
return(total);
}
public FilteredList <Product> GetAll(Filter filter)
{
_filterValidator.DefaultValidation(filter);
var filteredList = _productRepo.ReadAll(filter);
foreach (var product in filteredList.List)
{
_productValidator.DefaultValidation(product);
_priceCalc.CalculatePrice(product);
}
return(filteredList);
}
public Order(DateTime date, string paymentType, Package package, string senderName, Address sender, string recipientName, Address recipient, List <Service> services, IPriceCalculator priceCalculator)
{
Paid = false;
Date = date;
PaymentType = paymentType;
Status = "Submitted";
Package = package;
SenderName = senderName;
Sender = sender;
RecipientName = recipientName;
Recipient = recipient;
Services = services;
Price = priceCalculator.CalculatePrice(this);
}
public async Task <List <Tour> > SearchAsync(TourSearchRequest tourSearchRequest, CancellationToken cancellationToken)
{
var tours = _tourRepository.Tours
.Where(tourSearchRequest.Criteria)
.ApplySorting(tourSearchRequest)
.Take(_settings.ToursPackSize)
.ToList();
var personCount = tourSearchRequest.PersonCount.GetValueOrDefault(_settings.DefaultPersonCount);
await tours.ForEachAsync(Environment.ProcessorCount, x => _priceCalculator.CalculatePrice(x, personCount));
var random = new Random((int)DateTime.Now.Ticks);
await Task.Delay(random.Next(3000, 17000), cancellationToken);
return(tours);
}
public ActionResult CreateStepThree(int?id, int ticketsChildren, int[] seats)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Showing showing = repo.GetById <Showing>(id);
if (showing == null)
{
return(HttpNotFound());
}
double price = 0;
for (int i = 0; i < seats.Length; i++)
{
price += priceCalculator.CalculatePrice(showing, i < ticketsChildren);
}
Order order = new Order()
{
NumberOfTickets = seats.Length,
ShowingId = showing.Id,
TotalPrice = price,
};
repo.Create <Order>(order);
repo.Save();
foreach (int seatId in seats)
{
repo.Create <OrderSeat>(new OrderSeat()
{
OrderId = order.Id, SeatId = seatId
});
}
repo.Save();
ViewBag.ShowingID = id;
ViewBag.OrderID = order.Id;
return(View(order));
}
public ResponseMessage ExecuteOperation(RequestMessage request)
{
try
{
Order order = _orderRepository.CreateOrder();
order.OrderItems.AddRange(request.OrderItems);
foreach (OrderItem item in order.OrderItems)
{
InventoryItem inventoryItem = _inventoryService.GetInventoryItem(item.ItemCode);
if (item.Quantity <= inventoryItem.QuantityOnHand)
{
inventoryItem.QuantityOnHand -= item.Quantity;
item.Weight = item.WeightPerUnit * (float)item.Quantity;
_priceCalculator.CalculatePrice(item, inventoryItem);
item.State = OrderItemState.Filled;
}
else
{
item.State = OrderItemState.NotEnoughQuantityOnHand;
}
}
order.State = order.OrderItems.All(o => o.State == OrderItemState.Filled)
? OrderState.Filled
: OrderState.Processing;
_orderRepository.AddOrder(order);
// save inventory
_inventoryService.UpdateInventory();
// save order
_orderRepository.UpdateOrders();
return(_responseMessageFactory.CreateOrderSubmissionResponseMessage(request, order));
}
catch (Exception ex)
{
_loggerService.WriteLine("Exception during operation SubmitOrder: " + ex, "SubmitOrderError");
return(_responseMessageFactory.CreateErrorResponseMessage(ex));
}
}
/// <summary>
/// This method applies the appropriate discounts on each of the scanned item
/// The discount is applied by invoking the corresponding Discount Type interface
/// </summary>
public void CheckOut()
{
try
{
//Assign product details to each scanned item
AssignProductDetailsToScannedItems();
//get unique scanned items
var uniqueProductIds = scannedItems.Select(i => i.ProductId).Distinct().ToList();
//Apply the discount for each set of unique scanned items
uniqueProductIds.ForEach(pId =>
{
//If the scanned item is not present in the Product catalog then price will not be calculated
//If the scanned item is not present in the Product catalog then Product id = 0
if (pId != 0)
{
var items = scannedItems.FindAll(item => item.ProductId == pId);
var discountType = Products.Find(p => p.ProductId == pId).DiscountType;
calculator = PriceCalculatorFactory.GetPriceCalculator(discountType);
if (calculator != null)
{
var discount = Discounts.Find(dis => dis.ProductId == pId);
//Call the Calculator
calculator.CalculatePrice(items, discount);
}
}
});
}
catch (Exception ex)
{
throw new ApplicationException("Exception during Checkout process", ex);
}
PrintReceipt();
}
public double CalculatePrice()
{
return(Math.Round(_priceCalculator.CalculatePrice(ShoppingList) + _priceCalculator.CalculateTax(ShoppingList), 2));
}
public decimal CalculatePrice(int itemsCount)
{
return((itemsCount / volumeSize) * volumePrice + singleUnitPriceCalculator.CalculatePrice(itemsCount % volumeSize));
}
public decimal GetTotalPrice(decimal discountRate)
{
return(_priceCalculator.CalculatePrice(_productsCount, discountRate));
}
public void Confirm5()
{
var result = priceCalculator.CalculatePrice();
this.paymentGateway.CapturePayment(result.Amount, result.VatAmount);
}
public decimal GetTotalCost()
{
return(_orderItems.Sum(orderItem => _priceCalculator.CalculatePrice(CurrentCustomer, orderItem)));
}
public decimal GetTotalPrice(decimal discountRate)
{
return(priceCalculator.CalculatePrice(itemsCount, discountRate));
}
public decimal CalculateTotal()
{
return(_priceCalculator.CalculatePrice(_orderList));
}
/// <summary>
/// Use the price calculator specified to get the total price.
/// </summary>
/// <returns></returns>
public decimal GetTotalPrice()
{
return(priceCalculator.CalculatePrice(itemsCount));
}
public void CalculatePrice()
{
PriceCalculator = PriceCalculator.CalculatePrice(CartProducts);
CartProducts = PriceCalculator.UpdatedCartProducts;
CartTotalValue = PriceCalculator.TotalOrderValue;
}