public IActionResult AddProcurements()
        {
            var query = from r in _context.Books select r;
            //change to < r.ReplenishMinimum, exclude books on active procurement
            List <Book> allBooks = new List <Book>();

            query    = query.Where(r => r.Inventory < r.ReplenishMinimum);
            query    = query.Include(r => r.Procurements).Include(r => r.Reviews);
            allBooks = query.ToList();

            List <Procurement> allprocs = new List <Procurement>();
            var procquery = from p in _context.Procurements select p;

            procquery = procquery.Include(p => p.Book).Include(p => p.Employee);
            allprocs  = procquery.ToList();

            String  strUserId = User.Identity.Name;
            AppUser apvmuser  = _context.Users.FirstOrDefault(u => u.UserName == strUserId);


            List <AddProcurementVM> BooksToOrder = new List <AddProcurementVM>();

            foreach (Book book in allBooks)
            {
                AddProcurementVM apvm = new AddProcurementVM();
                apvm.Title                = book.Title;
                apvm.ProcurementDate      = System.DateTime.Today;
                apvm.BookID               = book.BookID;
                apvm.Author               = book.Author;
                apvm.AvgRatingProc        = (decimal)book.AvgRating;
                apvm.Cost                 = book.BookCost;
                apvm.userID               = User.Identity.Name;
                apvm.Inventory            = book.Inventory;
                apvm.InventoryMinimum     = book.ReplenishMinimum;
                apvm.SellingPrice         = book.SalesPrice;
                apvm.ProfitMargin         = ((Decimal)book.AvgSalesPrice - (Decimal)book.AvgBookCost);
                apvm.IncludeInProcurement = true;
                apvm.QuantityToOrder      = 5;
                BooksToOrder.Add(apvm);

                foreach (Procurement proc in allprocs)
                {
                    if (proc.ProcurementStatus == false)
                    {
                        if (book.BookID == proc.Book.BookID)
                        {
                            BooksToOrder.Remove(apvm);
                        }
                    }
                }
            }

            return(View(BooksToOrder));
        }
        public IActionResult ManualProcurement()
        {
            ViewBag.TotalBooks = _db.Books.Count();

            var         query    = from r in _db.Books select r;
            List <Book> allBooks = new List <Book>();

            query    = query.Include(b => b.Reviews);
            allBooks = query.ToList();

            List <Procurement> allprocs = new List <Procurement>();
            var procquery = from p in _db.Procurements select p;

            procquery = procquery.Include(p => p.Book).Include(p => p.Employee);
            allprocs  = procquery.ToList();

            String  strUserId = User.Identity.Name;
            AppUser apvmuser  = _db.Users.FirstOrDefault(u => u.UserName == strUserId);

            List <AddProcurementVM> BooksToOrder = new List <AddProcurementVM>();

            foreach (Book book in allBooks)
            {
                AddProcurementVM apvm = new AddProcurementVM();
                apvm.Title                = book.Title;
                apvm.ProcurementDate      = System.DateTime.Today;
                apvm.BookID               = book.BookID;
                apvm.Author               = book.Author;
                apvm.AvgRatingProc        = (decimal)book.AvgRating;
                apvm.PublishDate          = book.PublishDate;
                apvm.Cost                 = book.BookCost;
                apvm.userID               = User.Identity.Name;
                apvm.Inventory            = book.Inventory;
                apvm.InventoryMinimum     = book.ReplenishMinimum;
                apvm.SellingPrice         = book.SalesPrice;
                apvm.ProfitMargin         = ((Decimal)book.AvgSalesPrice - (Decimal)book.AvgBookCost);
                apvm.IncludeInProcurement = false;
                apvm.QuantityToOrder      = 5;
                BooksToOrder.Add(apvm);

                foreach (Procurement proc in allprocs)
                {
                    if (proc.ProcurementStatus == false)
                    {
                        if (book.BookID == proc.Book.BookID)
                        {
                            BooksToOrder.Remove(apvm);
                        }
                    }
                }
            }
            ViewBag.SelectedBooksCount = BooksToOrder.Count();
            return(View(BooksToOrder));
        }
        public IActionResult AddProcurements(List <AddProcurementVM> procurementVMs)
        {
            foreach (AddProcurementVM apvm in procurementVMs)
            {
                if (apvm.IncludeInProcurement == true)
                {
                    if (apvm.Cost <= 0 || apvm.QuantityToOrder <= 0)
                    {
                        var query = from r in _context.Books select r;
                        //change to < r.ReplenishMinimum, exclude books on active procurement
                        List <Book> allBooks = new List <Book>();
                        query    = query.Where(r => r.Inventory < r.ReplenishMinimum);
                        query    = query.Include(r => r.Procurements).Include(r => r.Reviews);
                        allBooks = query.ToList();

                        List <Procurement> allprocs = new List <Procurement>();
                        var procquery = from p in _context.Procurements select p;
                        procquery = procquery.Include(p => p.Book).Include(p => p.Employee);
                        allprocs  = procquery.ToList();

                        String  strUserId = User.Identity.Name;
                        AppUser apvmuser  = _context.Users.FirstOrDefault(u => u.UserName == strUserId);


                        List <AddProcurementVM> BooksToOrder = new List <AddProcurementVM>();
                        foreach (Book book in allBooks)
                        {
                            AddProcurementVM apvm2 = new AddProcurementVM();
                            apvm2.Title                = book.Title;
                            apvm2.ProcurementDate      = System.DateTime.Today;
                            apvm2.BookID               = book.BookID;
                            apvm2.Author               = book.Author;
                            apvm2.AvgRatingProc        = (decimal)book.AvgRating;
                            apvm2.Cost                 = book.BookCost;
                            apvm2.userID               = User.Identity.Name;
                            apvm2.Inventory            = book.Inventory;
                            apvm2.InventoryMinimum     = book.ReplenishMinimum;
                            apvm2.SellingPrice         = book.SalesPrice;
                            apvm2.ProfitMargin         = ((Decimal)book.AvgSalesPrice - (Decimal)book.AvgBookCost);
                            apvm2.IncludeInProcurement = true;
                            apvm2.QuantityToOrder      = 5;
                            BooksToOrder.Add(apvm2);

                            foreach (Procurement proc in allprocs)
                            {
                                if (proc.ProcurementStatus == false)
                                {
                                    if (book.BookID == proc.Book.BookID)
                                    {
                                        BooksToOrder.Remove(apvm2);
                                    }
                                }
                            }
                        }
                        ViewBag.ProcurementError = "Quantity and Cost need to be greater than zero";
                        return(View("AddProcurements", BooksToOrder));
                    }
                    else
                    {
                        ViewBag.ProcurementError = "";
                        Book    apvmbook = _context.Books.FirstOrDefault(r => r.BookID == apvm.BookID);
                        string  strID    = apvm.userID;
                        AppUser apvmuser = _context.Users.FirstOrDefault(u => u.UserName == apvm.userID);


                        Procurement procurement = new Procurement()
                        {
                            Book = apvmbook, Employee = apvmuser
                        };
                        procurement.Price             = apvm.Cost;
                        procurement.ProcurementDate   = apvm.ProcurementDate;
                        procurement.ProcurementStatus = false;
                        procurement.Quantity          = apvm.QuantityToOrder;

                        String  userId = User.Identity.Name;
                        AppUser user   = _context.Users.FirstOrDefault(u => u.UserName == userId);
                        procurement.Employee = user;

                        //update cost to be latest cost paid
                        apvmbook.BookCost = apvm.Cost;

                        _context.Books.Update(apvmbook);
                        _context.Procurements.Add(procurement);
                        _context.SaveChanges();
                    }
                }

                //check to see if cost and quantity is greater than zero
            }

            return(RedirectToAction("Index"));
        }
        public IActionResult DetailedMProcurement(string SearchTitle, string SearchAuthor, string SearchUniqueID, int SearchGenre, DisplayBooks SelectedStock, SortOrderOpt SortButton)
        {
            List <Book> SelectedBooks = new List <Book>();

            var query = from r in _db.Books select r;

            //title
            if (!string.IsNullOrEmpty(SearchTitle))
            {
                query = query.Where(r => r.Title.Contains(SearchTitle));
            }

            //author
            if (!string.IsNullOrEmpty(SearchAuthor))
            {
                query = query.Where(r => r.Author.Contains(SearchAuthor));
            }

            //unique number
            if (!string.IsNullOrEmpty(SearchUniqueID))
            {
                int intUniqueNumber;
                try
                {
                    intUniqueNumber = Convert.ToInt32(SearchUniqueID);
                }
                catch
                {
                    //Add a message for the viewbag
                    ViewBag.Message = "You must enter a valid unique ID";

                    //re-populate drop down
                    //ViewBag.AllGenres .....

                    //Send user back to home page
                    return(View("DetailedSearch")); //may need to change what goes in ""
                }

                query = query.Where(r => r.UniqueID == intUniqueNumber);
            }



            //genre
            if (SearchGenre != 0) // 0 = they chose "all genres" from the drop-down
            {
                Genre GenreToDisplay = _db.Genres.Find(SearchGenre);
                query = query.Where(r => r.Genre == GenreToDisplay);
            }


            //selected books - all or in stock only
            switch (SelectedStock)
            {
            case DisplayBooks.AllBooks:
                break;

            case DisplayBooks.InStock:
                query = query.Where(r => r.Inventory > 0);
                break;

            default:
                break;
            }

            SelectedBooks = query.ToList();
            ViewBag.SelectedBooksCount = SelectedBooks.Count();
            ViewBag.TotalBooks         = _db.Books.Count();

            switch (SortButton)
            {
            case SortOrderOpt.DontSort: break;

            case SortOrderOpt.Title:
                return(View("Index", SelectedBooks.OrderBy(r => r.Title)));

            case SortOrderOpt.Author:
                return(View("Index", SelectedBooks.OrderBy(r => r.Author)));

            case SortOrderOpt.MostPopular:
                return(View("Index", SelectedBooks.OrderBy(r => r.BookID)));

            case SortOrderOpt.Newest:
                return(View("Index", SelectedBooks.OrderByDescending(r => r.PublishDate)));

            case SortOrderOpt.Oldest:
                return(View("Index", SelectedBooks.OrderBy(r => r.PublishDate)));

            case SortOrderOpt.HighestRating:
                return(View("Index", SelectedBooks.OrderByDescending(r => r.AvgRating)));
            }


            SelectedBooks = query.Include(r => r.Reviews).Include(r => r.Genre).ToList();
            ViewBag.SelectedBooksCount = SelectedBooks.Count();
            ViewBag.TotalBooks         = _db.Books.Count();


            List <Procurement> allprocs = new List <Procurement>();
            var procquery = from p in _db.Procurements select p;

            procquery = procquery.Include(p => p.Book).Include(p => p.Employee);
            allprocs  = procquery.ToList();

            String  strUserId = User.Identity.Name;
            AppUser apvmuser  = _db.Users.FirstOrDefault(u => u.UserName == strUserId);

            List <AddProcurementVM> BooksToOrder = new List <AddProcurementVM>();

            foreach (Book book in SelectedBooks)
            {
                AddProcurementVM apvm = new AddProcurementVM();
                apvm.Title                = book.Title;
                apvm.ProcurementDate      = System.DateTime.Today;
                apvm.BookID               = book.BookID;
                apvm.Author               = book.Author;
                apvm.AvgRatingProc        = (decimal)book.AvgRating;
                apvm.PublishDate          = book.PublishDate;
                apvm.Cost                 = book.BookCost;
                apvm.userID               = User.Identity.Name;
                apvm.Inventory            = book.Inventory;
                apvm.InventoryMinimum     = book.ReplenishMinimum;
                apvm.SellingPrice         = book.SalesPrice;
                apvm.ProfitMargin         = ((Decimal)book.AvgSalesPrice - (Decimal)book.AvgBookCost);
                apvm.IncludeInProcurement = false;
                apvm.QuantityToOrder      = 5;
                BooksToOrder.Add(apvm);

                foreach (Procurement proc in allprocs)
                {
                    if (proc.ProcurementStatus == false)
                    {
                        if (book.BookID == proc.Book.BookID)
                        {
                            BooksToOrder.Remove(apvm);
                        }
                    }
                }
            }
            if (BooksToOrder.Count == 0)
            {
                ViewBag.SelectedBooksCount = 0;
            }
            ViewBag.DetailedMError = "";
            return(View(BooksToOrder));
        }