public async Task <bool> checkIfStockAvailable(Order_itemModel order_itemModel)
{
bool isStockAvailable = false;
var itemFound = (await Bl.BlItem.searchItemAsync(new Item {
Ref = order_itemModel.TxtItem_ref
}, ESearchOption.AND)).FirstOrDefault();
if (itemFound != null && itemFound.Stock >= order_itemModel.Order_Item.Quantity - Utility.intTryParse(order_itemModel.TxtOldQuantity))
{
isStockAvailable = true;
}
return(isStockAvailable);
}
private async Task createNewQuote()
{
Singleton.getDialogueBox().showSearch(ConfigurationManager.AppSettings["create_message"]);
List <Order_itemModel> order_itemModelList = new List <Order_itemModel>();
OrderModel quote = (OrderModel)_main.ModelCreator.createModel(QOBDModels.Enums.EModel.ORDER);
quote.AddressList = Singleton.getCart().ClientModel.AddressList;
quote.CLientModel = Singleton.getCart().ClientModel;
quote.AgentModel = new AgentModel {
Agent = Bl.BlSecurity.GetAuthenticatedUser()
};
quote.TxtDate = DateTime.Now.ToString();
quote.TxtStatus = EOrderStatus.Quote.ToString();
var currenciesFound = Bl.BlOrder.searchCurrency(new QOBDCommon.Entities.Currency {
IsDefault = true
}, ESearchOption.AND);
if (currenciesFound.Count() > 0)
{
quote.CurrencyModel = currenciesFound.Select(x => new CurrencyModel {
Currency = x
}).Single();
quote.Order.CurrencyId = quote.CurrencyModel.Currency.ID;
}
var savedQuoteList = await Bl.BlOrder.InsertOrderAsync(new List <Entity.Order> {
quote.Order
});
if (savedQuoteList.Count > 0)
{
foreach (Cart_itemModel cart_itemModel in Singleton.getCart().CartItemList)
{
Order_itemModel order_itemModel = new Order_itemModel
{
ItemModel = new ItemModel {
Item = cart_itemModel.Item
},
TxtOldQuantity = cart_itemModel.TxtOldQuantity,
Order_Item = new Entity.Order_item
{
Item_ref = cart_itemModel.TxtRef,
ItemId = cart_itemModel.Item.ID,
Price = cart_itemModel.Item.Price_sell,
Price_purchase = cart_itemModel.Item.Price_purchase,
OrderId = savedQuoteList[0].ID,
Quantity = Utility.intTryParse(cart_itemModel.TxtQuantity)
}
};
order_itemModelList.Add(order_itemModel);
}
var savedOrderList = await Bl.BlOrder.InsertOrder_itemAsync(order_itemModelList.Select(x => x.Order_Item).ToList());
Singleton.getCart().CartItemList.Clear();
Singleton.getCart().ClientModel.Client = new QOBDCommon.Entities.Client();
if (savedQuoteList.Count > 0)
{
await Singleton.getDialogueBox().showAsync("Quote ID(" + new OrderModel {
Order = savedQuoteList[0]
}.TxtID + ") has been created successfully!");
}
// lock items to prevent deletion
QuoteDetailViewModel.lockOrUnlockedOrder_itemItems(order_itemModelList);
}
else
{
string errorMessage = "Error occurred while creating the quote!";
Log.error(errorMessage, EErrorFrom.ORDER);
await Singleton.getDialogueBox().showAsync(errorMessage);
}
Singleton.getDialogueBox().IsDialogOpen = false;
}
private async Task updateQuote()
{
Singleton.getDialogueBox().showSearch(ConfigurationManager.AppSettings["update_message"]);
List <Entity.Order_item> order_itemList = new List <Entity.Order_item>();
SelectedQuoteModel.TxtDate = DateTime.Now.ToString();
var savedQuoteList = await Bl.BlOrder.UpdateOrderAsync(new List <Entity.Order> {
SelectedQuoteModel.Order
});
if (savedQuoteList.Count > 0)
{
foreach (Cart_itemModel cart_itemModel in Singleton.getCart().CartItemList)
{
// update existing item in the cart
Order_itemModel order_itemModelFound = QuoteDetailViewModel.Order_ItemModelList.Where(x => x.TxtItem_ref == cart_itemModel.TxtRef).FirstOrDefault();
if (order_itemModelFound != null)
{
order_itemModelFound.Order_Item.ItemId = cart_itemModel.Item.ID;
order_itemModelFound.TxtQuantity = cart_itemModel.TxtQuantity;
order_itemModelFound.TxtPrice = cart_itemModel.TxtPrice_sell;
order_itemModelFound.TxtPrice_purchase = cart_itemModel.TxtPrice_purchase;
order_itemList.Add(order_itemModelFound.Order_Item);
}
// new item in the cart
else
{
Order_itemModel newOrder_itemModel = new Order_itemModel();
newOrder_itemModel.Order = savedQuoteList[0];
newOrder_itemModel.ItemModel.Item = cart_itemModel.Item;
newOrder_itemModel.TxtOldQuantity = cart_itemModel.TxtOldQuantity;
newOrder_itemModel.TxtItem_ref = cart_itemModel.TxtRef;
newOrder_itemModel.Order_Item.ItemId = cart_itemModel.Item.ID;
newOrder_itemModel.TxtPrice = cart_itemModel.TxtPrice_sell;
newOrder_itemModel.TxtPrice_purchase = cart_itemModel.TxtPrice_purchase;
newOrder_itemModel.Order_Item.OrderId = savedQuoteList[0].ID;
newOrder_itemModel.TxtQuantity = cart_itemModel.TxtQuantity;
order_itemList.Add(newOrder_itemModel.Order_Item);
}
}
// get unselected item from the list for deletion
var order_itemListToDelete = QuoteDetailViewModel.Order_ItemModelList.Where(x => Singleton.getCart().CartItemList.Where(y => y.TxtRef == x.TxtItem_ref).Count() == 0).ToList();
// update the quote items
await Bl.BlOrder.UpdateOrder_itemAsync(order_itemList.Where(x => x.ID != 0).ToList());
// add new items to the quote
var addedItemList = await Bl.BlOrder.InsertOrder_itemAsync(order_itemList.Where(x => x.ID == 0).ToList());
// lock items to prevent deletion
if (addedItemList.Count > 0)
{
QuoteDetailViewModel.lockOrUnlockedOrder_itemItems(order_itemList.Where(x => x.ID == 0).Select(x => new Order_itemModel {
Order_Item = x
}).ToList());
}
// deleting unchecked items from the quote
var order_itemDeletionFaildList = await Bl.BlOrder.DeleteOrder_itemAsync(order_itemListToDelete.Select(x => x.Order_Item).ToList());
// unlock items to allow deletion
if (order_itemDeletionFaildList.Count == 0)
{
QuoteDetailViewModel.lockOrUnlockedOrder_itemItems(order_itemListToDelete, isLocked: false);
}
foreach (var order_itemModelToDelete in order_itemListToDelete)
{
QuoteDetailViewModel.Order_ItemModelList.Remove(order_itemModelToDelete);
}
Singleton.getCart().CartItemList.Clear();
Singleton.getCart().ClientModel.Client = new QOBDCommon.Entities.Client();
if (savedQuoteList.Count > 0)
{
await Singleton.getDialogueBox().showAsync("Quote ID(" + new OrderModel {
Order = savedQuoteList[0]
}.TxtID + ") has been updated successfully!");
}
}
else
{
string errorMessage = "Error occurred while updating the quote ID[" + SelectedQuoteModel.TxtID + "]!";
Log.error(errorMessage, EErrorFrom.ORDER);
await Singleton.getDialogueBox().showAsync(errorMessage);
}
Singleton.getDialogueBox().IsDialogOpen = false;
}
