Example #1
0
        public async Task <bool> AddBid(Bid model)
        {
            int currentMaxBid;

            var bids = _repository.GetBidsAsync(model.AuktionID).Result;

            if (bids.Count() < 1)
            {
                var auction = await _auctionRepository.GetAuctionAsync(model.AuktionID);

                currentMaxBid = auction.Utropspris;
            }
            else
            {
                var maxBid = bids.Select(x => x.Summa).Max();
                currentMaxBid = maxBid;
            }

            if (model.Summa > currentMaxBid)
            {
                return(await _repository.AddBid(model));
            }
            else
            {
                return(false);
            }
        }
Example #2
0
        public Chart GetValuesForChart(string userId, bool onlyOwnedAuctions, string month)
        {
            var allAuctions = _auctionRepository.GetAuctionsAsync().Result;

            //Gets auctions from chosen month
            allAuctions = allAuctions.Where(x => DateTime.Parse(x.StartDatum).ToString("MMMM") == month).ToList();

            if (onlyOwnedAuctions)
            {
                allAuctions = allAuctions.Where(x => x.SkapadAv.ToString() == userId.ToString()).ToList();
            }

            var sumOfFinalBids = 0;

            foreach (var item in allAuctions)
            {
                var bids = _bidRepository.GetBidsAsync(item.AuktionID).Result;

                sumOfFinalBids = sumOfFinalBids + (bids.OrderByDescending(x => x.Summa).Select(x => x.Summa).FirstOrDefault());
            }

            var sumOfStartingBids = allAuctions.Select(x => x.Utropspris).Sum();

            var chartArray = CalculateChart(sumOfStartingBids, sumOfFinalBids);

            var chartModel = new Chart()
            {
                StartingBids = chartArray[0],
                FinalBids    = chartArray[1],
                Difference   = chartArray[2]
            };


            return(chartModel);
        }
        public async Task <Models.Bid> ShowLastBidForProductAsync(Guid productId)
        {
            Task <Models.Bid> taskInvoke = Task <Models.Bid> .Factory.StartNew(() =>
            {
                _bidRepository.Configure();
                var listBid = _bidRepository.GetBidsAsync().Result.Where(b => b.ProductId == productId);
                if (listBid.IsNullOrEmpty())
                {
                    return(null);
                }

                var listBidDTO = listBid.Select(b => Mapper.Map <Models.Bid>(b));

                return(listBidDTO.MaxBy(b => b.Price));
            });

            return(await taskInvoke);
        }
        public async Task <bool> DeleteAuctionAsync(int auctionId)
        {
            var hasBids = _bidRepository.GetBidsAsync(auctionId).Result.Count();

            if (hasBids > 0)
            {
                return(false);
            }
            else
            {
                var result = await _repository.DeleteAuctionAsync(auctionId);

                return(result);
            }
        }