public async Task <decimal> RealTimePrice(int productId, decimal euroSpend)
        {
            //List from the ask table sorted ascending
            var     offersToBuy         = db.Ask.Where(x => x.ProductId == productId).OrderBy(x => x.PriceAsk).ToList();
            decimal quantityToBeOrdered = 0; //the quantity that users can buy with his euroSpend

            foreach (var item in offersToBuy)
            {
                if ((item.PriceAsk * item.Quantity) % euroSpend == item.PriceAsk * item.Quantity)
                {
                    euroSpend -= item.PriceAsk * item.Quantity;
                    db.Ask.Remove(item);
                    //increase wallet that belongs to user who had placed the ask
                    await _walletRepository.IncreaseWallet(item.PriceAsk *item.Quantity, item.UserAskId);

                    quantityToBeOrdered += item.Quantity; //increase the quantity of user's order
                    TradeHistory trade = new TradeHistory //initiate a new trade
                    {
                        Quantity          = item.Quantity,
                        Price             = item.PriceAsk,
                        Status            = "Buy",
                        DateofTransaction = DateTime.Now,
                        ProductId         = item.ProductId
                    };
                    await UpdateTradeHistory(trade);
                }
                else if (item.PriceAsk * item.Quantity == euroSpend)
                {
                    euroSpend -= item.PriceAsk * item.Quantity;
                    db.Ask.Remove(item);
                    //increase wallet that belongs to user who had placed the ask
                    await _walletRepository.IncreaseWallet(item.PriceAsk *item.Quantity, item.UserAskId);

                    quantityToBeOrdered += item.Quantity; //increase the quantity of user's order
                    decimal closedPrice = item.PriceAsk;  //the new current product price
                    //Find current product price
                    await SetCurrentPrice(productId, closedPrice);

                    TradeHistory trade = new TradeHistory //initiate a new trade
                    {
                        Quantity          = item.Quantity,
                        Price             = item.PriceAsk,
                        Status            = "Buy",
                        DateofTransaction = DateTime.Now,
                        ProductId         = item.ProductId
                    };
                    await UpdateTradeHistory(trade);

                    break;
                }
                else
                {
                    //reduce the quanity of ask
                    var itemForReduce = item;
                    itemForReduce.Quantity -= euroSpend / item.PriceAsk;
                    db.Ask.Update(itemForReduce);
                    await db.SaveChangesAsync();

                    //increase wallet that belongs to user who had placed the ask
                    await _walletRepository.IncreaseWallet(euroSpend, item.UserAskId);

                    quantityToBeOrdered += euroSpend / item.PriceAsk; //increase the quantity of user's order
                    decimal closedPrice = item.PriceAsk;              //the new current product price
                    await SetCurrentPrice(productId, closedPrice);

                    TradeHistory trade = new TradeHistory //initiate a new trade
                    {
                        Quantity          = euroSpend / item.PriceAsk,
                        Price             = item.PriceAsk,
                        Status            = "Buy",
                        DateofTransaction = DateTime.Now,
                        ProductId         = item.ProductId
                    };
                    await UpdateTradeHistory(trade);

                    break;
                }
            }
            return(quantityToBeOrdered);
        }
        public async Task <decimal> RealTimePrice(int productId, decimal coinSell)
        {
            //List from the Offer  table sorted Descending
            var     offersToBuy = db.Offer.Where(x => x.ProductId == productId).OrderByDescending(x => x.PriceOffer).ToList();
            decimal moneyEarn   = 0; //money earned from selling the coinsell amount

            foreach (var item in offersToBuy)
            {
                if (item.Quantity > coinSell)
                {
                    //if offer in offer table is bigger than  the amount we enter
                    moneyEarn += coinSell * item.PriceOffer;
                    //reduce the quantity of the bid in offer table
                    item.Quantity -= coinSell;
                    db.Offer.Update(item);
                    //decrease the wallet of user who had placed the bod
                    //await _walletRepository.DecreaseWallet(coinSell * item.PriceOffer, item.UserOfferId);
                    await _walletRepository.DecreaseWallet(coinSell *item.PriceOffer, item.UserOfferId);

                    await db.SaveChangesAsync();

                    decimal closedPrice = item.PriceOffer; //the new current product price
                    //Find current product price
                    await SetCurrentPrice(productId, closedPrice);

                    TradeHistory trade = new TradeHistory //initiate a new trade
                    {
                        Quantity          = coinSell,
                        Price             = item.PriceOffer,
                        Status            = "Sell",
                        DateofTransaction = DateTime.Now,
                        ProductId         = item.ProductId
                    };
                    await UpdateTradeHistory(trade);

                    break;
                }
                else if (item.Quantity == coinSell)
                {
                    db.Offer.Remove(item);

                    moneyEarn += coinSell * item.PriceOffer; //

                    decimal closedPrice = item.PriceOffer;   //the new current product price

                    //Find current product price
                    await SetCurrentPrice(productId, closedPrice);

                    await _walletRepository.DecreaseWallet(coinSell *item.PriceOffer, item.UserOfferId);

                    TradeHistory trade = new TradeHistory //initiate a new trade
                    {
                        Quantity          = item.Quantity,
                        Price             = item.PriceOffer,
                        Status            = "Sell",
                        DateofTransaction = DateTime.Now,
                        ProductId         = item.ProductId
                    };
                    await UpdateTradeHistory(trade);

                    break;
                }
                else
                {
                    db.Offer.Remove(item);
                    await db.SaveChangesAsync();

                    coinSell -= item.Quantity;

                    moneyEarn += item.Quantity * item.PriceOffer; //increase the quantity of user's order
                    await _walletRepository.DecreaseWallet(item.Quantity *item.PriceOffer, item.UserOfferId);

                    TradeHistory trade = new TradeHistory //initiate a new trade
                    {
                        Quantity          = item.Quantity,
                        Price             = item.PriceOffer,
                        Status            = "Sell",
                        DateofTransaction = DateTime.Now,
                        ProductId         = item.ProductId
                    };
                    await UpdateTradeHistory(trade);
                }
            }
            return(moneyEarn);
        }