public async Task <CheckoutSummary> CheckoutAsync(string userId)
{
var result = new CheckoutSummary();
result.Date = DateTime.UtcNow;
result.Products = new List <CheckoutProduct>();
IUserActor userActor = GetUserActor(userId);
BasketItem[] basket = await userActor.GetBasket();
var catalogService = GetProductCatalogService();
foreach (var basketLine in basket)
{
var product = await catalogService.GetProduct(basketLine.ProductId);
var checkoutProduct = new CheckoutProduct
{
Product = product,
Price = product.Price,
Quantity = basketLine.Quantity
};
result.Products.Add(checkoutProduct);
}
result.TotalPrice = result.Products.Sum(p => p.Price);
await userActor.ClearBasket();
await AddToHistoryAsync(result);
return(result);
}
public async Task <CheckoutSummary> CheckoutCart(string userId)
{
var result = new CheckoutSummary
{
Date = DateTime.UtcNow,
Products = new List <CheckoutProduct>()
};
var userActor = UserActorResolver.Resolve(userId);
var cartItems = await userActor.GetCartItems();
var catalogService = ProductCatalogServiceResolver.Resolve();
foreach (var cartItem in cartItems)
{
var product = await catalogService.GetProduct(cartItem.Key);
result.Products.Add(new CheckoutProduct
{
Product = product,
Price = product.Price,
Quantity = cartItem.Value
});
}
result.TotalPrice = result.Products.Sum(p => p.Price);
await userActor.ClearCart();
await AddToHistory(result);
return(result);
}
public async Task <CheckoutSummary> CheckoutAsync(string userId)
{
var result = new CheckoutSummary();
result.Date = DateTime.UtcNow;
result.Products = new List <CheckoutProduct>();
//get user basket
var userActor = GetUserActor(userId);
Dictionary <Guid, int> basket = await userActor.GetBasket();
//get catalogClient
IProductCatalogService catalogService = GetProductCatalogService();
foreach (var item in basket)
{
Product product = await catalogService.GetProduct(item.Key);
result.Products.Add(
new CheckoutProduct
{
Product = product,
Price = product.Price,
Quantity = item.Value
});
}
await userActor.ClearBasket();
await AddToHistoryAsync(result);
return(result);
}
public async Task <CheckoutSummary> CheckoutAsync(string userId)
{
var result = new CheckoutSummary();
result.Date = DateTime.UtcNow;
result.Products = new List <CheckoutProduct>();
// Get the user basket
IUserActor userActor = GetUserActor(userId);
BasketItem[] basket = await userActor.GetBasket();
IProductCatalogService catalogService = GetProductCatalogService();
foreach (var item in basket)
{
var product = await catalogService.GetProduct(item.ProductId);
var checkoutProduct = new CheckoutProduct()
{
Product = product,
Price = product.Price,
Quantity = item.Quantity
};
result.Products.Add(checkoutProduct);
}
return(result);
}
public async Task <CheckoutSummary> Checkout(string userId)
{
var result = new CheckoutSummary();
result.Date = DateTime.UtcNow;
result.Products = new List <CheckoutProduct>();
IUserActor userActor = GetUserActor(userId);
Dictionary <Guid, int> basket = await userActor.GetBasket();
IProductCatalogService catalogService = GetProductCatalogService();
foreach (KeyValuePair <Guid, int> basketLine in basket)
{
Product product = await catalogService.GetProduct(basketLine.Key);
var checkoutProduct = new CheckoutProduct
{
Product = product,
Price = product.Price,
Quantity = basketLine.Value
};
result.Products.Add(checkoutProduct);
}
result.TotalPrice = result.Products.Sum(p => p.Price);
await userActor.ClearBasket();
await AddToHistory(result);
return(result);
}
public async Task <CheckoutSummary> Checkout(string userId)
{
var result = new CheckoutSummary();
//call user actor to get the basket
IUserActor userActor = GetUserActor(userId);
Dictionary <Guid, int> basket = await userActor.GetBasket();
//get catalog client
IProductCatalogService catalogService = GetProductCatalogService();
//constuct CheckoutProduct items by calling to the catalog
foreach (KeyValuePair <Guid, int> basketLine in basket)
{
Product product = await catalogService.GetProduct(basketLine.Key);
var checkoutProduct = new CheckoutProduct
{
Product = product,
Price = product.Price,
Quantity = basketLine.Value
};
result.Products.Add(checkoutProduct);
}
//generate total price
result.TotalPrice = result.Products.Sum(p => p.Price);
//clear user basket
await userActor.ClearBasket();
await AddToHistory(result);
return(result);
}
public async Task <ApiCheckoutSummary> CheckoutAsync(string userId)
{
CheckoutSummary summary =
await GetCheckoutService().CheckoutAsync(userId);
return(ToApiCheckoutSummary(summary));
}
public async Task <CheckoutSummary> CheckoutAsync(string userId)
{
var checkoutSummary = new CheckoutSummary();
checkoutSummary.Date = DateTime.UtcNow;
checkoutSummary.Products = new List <CheckoutProduct>();
var userActor = GetUserActor(userId);
var basket = await userActor.GetBasketAsync();
var productCatalogService = GetProductCatalogService();
foreach (var basketLine in basket)
{
var product = await productCatalogService.GetProductAsync(basketLine.Key);
var checkoutProduct = new CheckoutProduct
{
Product = product,
Price = product.Price,
Quantity = basketLine.Value
};
checkoutSummary.Products.Add(checkoutProduct);
}
checkoutSummary.TotalPrice = checkoutSummary.Products.Sum(p => p.Price * p.Quantity);
await userActor.ClearBasketAsync();
await AddToHistory(userId, checkoutSummary);
return(checkoutSummary);
}
public async Task <CheckoutSummary> Checkout(string userId)
{
var result = new CheckoutSummary
{
Date = DateTime.UtcNow,
Products = new List <CheckoutProduct>()
};
var userActor = GetUserActor(userId);
var basket = await userActor.GetBasket();
var catalogService = GetProductCatalogService();
foreach (var basketLine in basket)
{
var product = await catalogService.GetProduct(basketLine.Key);
var checkoutProduct = new CheckoutProduct
{
Product = product,
Price = product.Price,
Quantity = basketLine.Value
};
result.Products.Add(checkoutProduct);
}
result.TotalPrice = result.Products.Sum(p => p.Price * p.Quantity);
await Task.WhenAll(userActor.ClearBasket(), AddToHistory(result)).ConfigureAwait(false);
return(result);
}
public override void Initialize()
{
// get the checkout summary from the Model
CheckoutSummary summary = _checkoutService.GetSummary(View.SessionID);
if (summary != null)
{
IList <ProductItem> productItems = new List <ProductItem>();
foreach (Product item in summary.Products)
{
productItems.Add(new ProductItem()
{
ProductName = item.ProductName, UnitPrice = item.UnitPrice
});
}
// set the properties to be displayed to the View
View.Products = productItems;
View.SubTotal = summary.SubTotal;
View.Discount = summary.Discount;
View.Total = summary.Total;
}
else
{
Navigation.GoTo(ViewPages.SessionNotFound);
}
}
private void OpenCheckoutPage(CheckoutSummary response)
{
_checkoutSummary.SaleSummary = response.SaleSummary;
_checkoutSummary.TenderSummary = response.TenderSummary;
NavigateService.Instance.NavigateToSaleSummary();
MessengerInstance.Send(_checkoutSummary);
}
public async Task <CheckoutSummaryViewModel> Checkout(string userId)
{
var service = GetCheckoutService();
CheckoutSummary summary = await service.Checkout(userId);
return(ToApiCheckoutSummary(summary));
}
private async void DeleySecondes(AckrooTenderMessage obj)
{
_checkoutSummary = await _checkoutBusinessLogic.SaleSummary();
_outStandingAmount = double.Parse(_checkoutSummary.TenderSummary.OutstandingAmount, System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.InvariantCulture);
IsEnabled = false;
await Task.Delay(5000).ContinueWith(x => bar());
}
private async Task AddToHistory(CheckoutSummary checkout)
{
var history = await StateManager.GetOrAddAsync<IReliableDictionary<DateTime, CheckoutSummary>>("history");
using (var tx = StateManager.CreateTransaction())
{
await history.AddAsync(tx, checkout.Date, checkout);
await tx.CommitAsync();
}
}
public async Task AddCheckoutInformationToHistory(CheckoutSummary checkoutSummary)
{
await StateManager.AddOrUpdateStateAsync("history",
new List <CheckoutSummary>() { checkoutSummary },
((s, list) =>
{
list.Add(checkoutSummary);
return(list);
}));
}
private async Task AddToHistoryAsync(CheckoutSummary summary)
{
IReliableDictionary <DateTime, CheckoutSummary> history =
await StateManager.GetOrAddAsync <IReliableDictionary <DateTime, CheckoutSummary> >(HISTORY_COLLECTION);
using (ITransaction tx = StateManager.CreateTransaction())
{
await history.AddAsync(tx, summary.Date, summary);
await tx.CommitAsync();
}
}
private void PromptMessage()
{
if (_promptMessages?.Count > 0)
{
OpenMessagePopup();
}
else
{
ClosePopupWithTextBox();
PerformAction(async() =>
{
_timer.Restart();
try
{
_poNumber = await _checkoutBusinessLogic.SaveProfilePrompt(
Helper.EncodeToBase64(!string.IsNullOrEmpty(_swipedCardNumber) ? _swipedCardNumber : CardNumber),
_cardSwipeInformation.ProfileId,
_messageDictionary);
if (_processForAmount)
{
MessengerInstance.Send(_poNumber, "CompleteAccountPaymentAfterValidations");
}
else if (!_performAptTender)
{
PaymentByCard();
}
else
{
CacheBusinessLogic.IsKickBack = true;
MessengerInstance.Send(new KickBackForTenderScreenMessage
{
PoNumber = _poNumber,
IsKickBack = true,
OutstandingAmount = _checkoutSummary?.TenderSummary?.OutstandingAmount
}, "CompleteAptTenderTransaction");
_checkoutSummary = null;
}
}
finally
{
// Navigating to tender only if APT tender needs not to be performed
if (!_performAptTender)
{
NavigateToTender();
}
_performAptTender = false;
_timer.Stop();
}
});
}
}
private ApiCheckoutSummary ToApiCheckoutSummary(CheckoutSummary summary) => new ApiCheckoutSummary
{
Products = summary.Products.Select(p => new ApiCheckoutProduct
{
ProductId = p.Product.Id,
ProductName = p.Product.Name,
Price = p.Price,
Quantity = p.Quantity
}).ToList(),
TotalPrice = summary.TotalPrice,
Date = summary.Date
};
public async Task <ApiCheckoutSummary> Checkout(string userId)
{
try
{
CheckoutSummary summary = await GetCheckoutService().Checkout(userId);
return(ToApiCheckoutSummary(summary));
}
catch (Exception e)
{
Console.WriteLine(e.Message);
return(null);
}
}
public async Task AddToHistoryAsync(CheckoutSummary checkout)
{
// Get or Create history list
IReliableDictionary <DateTime, CheckoutSummary> history =
await StateManager.GetOrAddAsync <IReliableDictionary <DateTime, CheckoutSummary> >("history");
using (ITransaction tx = StateManager.CreateTransaction())
{
// Add the new checkout to history.
await history.AddAsync(tx, checkout.Date, checkout);
await tx.CommitAsync();
}
}
private ApiCheckoutSummary ToApiCheckoutSummary(CheckoutSummary summary)
{
return(new ApiCheckoutSummary
{
Products = summary.Products.Select(x => new ApiCheckoutProduct {
ProductId = x.Product.Id,
ProductName = x.Product.Name,
Price = x.Product.Price,
Quantity = x.Quantity
}).ToList(),
Date = summary.Date,
TotalPrice = summary.TotalPrice
});
}
private ApiCheckoutSummary ToApiCheckoutSummary(CheckoutSummary model)
{
return(new ApiCheckoutSummary()
{
Products = model.Products.Select(p => new ApiCheckoutProduct()
{
ProductId = p.Product.Id,
ProductName = p.Product.Name,
Price = p.Price,
Quantity = p.Quantity
}).ToList(),
Date = model.Date,
TotalPrice = model.TotalPrice
});
}
private async Task AddToHistory(string userId, CheckoutSummary checkoutSummary)
{
var history = await StateManager.GetOrAddAsync <IReliableDictionary <string, List <CheckoutSummary> > >("history");
using (var tx = StateManager.CreateTransaction())
{
await history.AddOrUpdateAsync(
tx,
userId,
(id) => { var orders = new List <CheckoutSummary>(); orders.Add(checkoutSummary); return(orders); },
(id, oldOrders) => { oldOrders.Add(checkoutSummary); return(oldOrders); });
await tx.CommitAsync();
}
}
private ApiCheckoutSummary ToApiCheckoutSummary(CheckoutSummary summary)
{
return(new ApiCheckoutSummary()
{
Products = summary.Products.Select(p => new ApiCheckoutProduct()
{
ProductId = p.Product.Id,
ProductDescription = p.Product.Description,
Price = p.Product.Price,
Quantity = p.Quantity
}).ToList(),
Date = summary.Date,
TotalPrice = summary.TotalPrice
});
}
private CheckoutSummaryViewModel ToApiCheckoutSummary(CheckoutSummary model)
{
return(new CheckoutSummaryViewModel
{
Artifacts = model.Artifacts.Select(p => new CheckoutArtifactViewModel
{
ArtifactId = p.Artifact.Id,
ArtifactName = p.Artifact.Type,
Price = p.Price,
Quantity = p.Quantity,
}).ToList(),
Date = model.Date,
TotalPrice = model.Artifacts.Sum(x => x.Artifact.Price * x.Quantity)
});
}
public void AddToCart(string bookId)
{
Book book = _context.Books.Where(x => x.Id.Equals(bookId)).FirstOrDefault();
if (book is not null)
{
CheckoutSummary model = cartItems.Where(x => x.Book.Id.Equals(book.Id)).FirstOrDefault();
if (model is not null)
{
model.Quantity++;
}
else
{
cartItems.Add(new CheckoutSummary(book, 1));
}
}
}
private async Task CheckKickBackResponse(bool response)
{
_userInputForKickback = response;
CacheBusinessLogic.IsKickBack = true;
if (!response)
{
CacheBusinessLogic.KickbackAmount = null;
}
PerformAction(async() =>
{
_checkoutSummary = await _checkoutBusinessLogic.SaleSummary(false, false,
CacheBusinessLogic.KickbackAmount);
var checkKickBackresponse = await _kickBackBusinessLogic.CheckKickBackResponse(response);
AskForPin(_cardSwipeInformation.Pin);
});
}
public async Task <CheckoutSummary> Checkout(string userId)
{
var result = new CheckoutSummary();
result.Date = DateTime.Now;
result.Products = new List <CheckoutProduct>();
// Call the UserActor for the current user and get his shopping cart.
var userActor = GetUserActor(userId);
var cartContent = await userActor.GetCart();
var catalogService = GetProductCatalogService();
// Retrieve all product information in one call.
var productInformation = await catalogService.GetProducts(cartContent.Keys);
foreach (var item in cartContent)
{
if (productInformation.ContainsKey(item.Key) == false)
{
continue;
}
var product = productInformation[item.Key];
var checkoutProduct = new CheckoutProduct()
{
Product = product,
Price = product.Price,
Quantity = item.Value
};
result.Products.Add(checkoutProduct);
}
// Add the checkout to the history.
await userActor.AddCheckoutInformationToHistory(result);
await userActor.ClearCart();
return(result);
}
public async Task <CheckoutSummary> Checkout(string userId)
{
var result = new CheckoutSummary();
result.Date = DateTime.UtcNow;
result.Products = new List <CheckoutProduct>();
//call user actor to get the basket
var userActor = GetUserActor(userId);
var basket = await userActor.GetBasket();
//get catalog client
IProductCatalogService catalogService = GetProductCatalogService();
//constuct CheckoutProduct items by calling to the catalog
foreach (var basketLine in basket)
{
var product = await catalogService.GetProduct(basketLine.Key);
if (product != null)
{
var checkoutProduct = new CheckoutProduct
{
Product = product,
Price = product.Price,
Quantity = basketLine.Value
};
result.Products.Add(checkoutProduct);
}
}
//generate total price
result.TotalPrice = result.Products.Select(p => p.Quantity * p.Price).Sum();
//clear user basket
await userActor.ClearBasket();
await AddToHistory(result);
return(result);
}
public async Task <CheckoutSummary> Checkout(string userId)
{
var result = new CheckoutSummary()
{
Date = DateTime.UtcNow,
Products = new List <CheckoutProduct>()
};
IUserActor actor = CreateUserActor(userId);
var cart = await actor.GetCart();
IProductCatalogService productCatalogService = GetProductCatalogService();
var products = await productCatalogService.GetAllProducts();
var totalCost = 0.0;
foreach (var item in cart)
{
var productId = item.Key;
var quantity = item.Value;
var product = products.FirstOrDefault(p => p.Id == productId);
if (product != null)
{
result.Products.Add(new CheckoutProduct()
{
Product = product,
Quantity = quantity,
Price = product.Price * quantity
});
totalCost += (product.Price * quantity);
}
}
result.TotalPrice = totalCost;
//Clearing the cart since user has checkout all the products and add to history
await actor.ClearCart();
await AddToHistory(result);
return(result);
}
