public async Task <ActionResult> LockInvoice(ConfirmInvoiceViewModel confirmModel)
        {
            string       userId      = User.Identity.GetUserId();
            ShoppingCart sessionCart = GetCartFromSession(userId);
            int          orderNumber = sessionCart.Order.OrderNumber;

            if (ModelState.IsValid)
            {
                using (FreeMarketEntities db = new FreeMarketEntities())
                {
                    OrderHeader order = db.OrderHeaders.Find(orderNumber);
                    if (order != null)
                    {
                        order.OrderStatus     = "Invoiced";
                        db.Entry(order).State = System.Data.Entity.EntityState.Modified;
                        db.SaveChanges();

                        OrderHeader.SendInvoice(userId, order.OrderNumber);

                        AuditUser.LogAudit(28, string.Format("Order Number: {0}", order.OrderNumber), User.Identity.GetUserId());

                        sessionCart.Initialize(User.Identity.GetUserId());
                    }
                }
                return(RedirectToAction("PayInvoice", new { orderNumber = orderNumber }));
            }

            ConfirmInvoiceViewModel model = new ConfirmInvoiceViewModel(sessionCart);

            model.TermsAndConditions = confirmModel.TermsAndConditions;

            return(View("ConfirmInvoice", model));
        }
        public async Task <ActionResult> UpdateReviews(RateOrderViewModel model)
        {
            bool error = false;

            foreach (Product p in model.Products.Products)
            {
                if (p.ProductRating == 0)
                {
                    ModelState.AddModelError("", string.Format("{0}'s product rating may not be empty.", p.Description));
                    error = true;
                }

                if (p.PriceRating == 0)
                {
                    ModelState.AddModelError("", string.Format("{0}'s price rating may not be empty.", p.Description));
                    error = true;
                }
            }

            if (model.CourierRatings != null)
            {
                foreach (CourierReview c in model.CourierRatings)
                {
                    if (c.StarRating == 0)
                    {
                        ModelState.AddModelError("", string.Format("{0}'s rating may not be empty.", c.CourierName));
                        error = true;
                    }
                }
            }

            if (error)
            {
                return(View("RateOrder", model));
            }

            var user = UserManager.FindById(User.Identity.GetUserId());

            if (user == null)
            {
                return(View("Error"));
            }

            user.UnsubscribeFromRatings = model.Unsubscribe;
            await UserManager.UpdateAsync(user);

            using (FreeMarketEntities db = new FreeMarketEntities())
            {
                foreach (Product p in model.Products.Products)
                {
                    if (p.ReviewId == null)
                    {
                        ProductReview review = new ProductReview
                        {
                            Author         = user.Name,
                            Date           = DateTime.Now,
                            OrderNumber    = model.Order.OrderNumber,
                            PriceRating    = p.PriceRating,
                            ProductNumber  = p.ProductNumber,
                            ReviewContent  = p.ProductReviewText,
                            StarRating     = (short)p.ProductRating,
                            SupplierNumber = p.SupplierNumber,
                            UserId         = user.Id,
                            Approved       = null
                        };

                        db.ProductReviews.Add(review);
                    }
                    else
                    {
                        ProductReview review = db.ProductReviews.Find(p.ReviewId);

                        if (review != null)
                        {
                            if (review.PriceRating != p.PriceRating ||
                                review.ReviewContent != p.ProductReviewText ||
                                review.StarRating != (short)p.ProductRating)
                            {
                                review.Date          = DateTime.Now;
                                review.PriceRating   = p.PriceRating;
                                review.ReviewContent = p.ProductReviewText;
                                review.StarRating    = (short)p.ProductRating;
                                review.Approved      = null;
                            }

                            db.Entry(review).State = System.Data.Entity.EntityState.Modified;
                        }
                    }
                }

                if (model.CourierRatings != null)
                {
                    foreach (CourierReview cReview in model.CourierRatings)
                    {
                        if (cReview.ReviewId == 0)
                        {
                            CourierReview review = new CourierReview
                            {
                                Author        = user.Name,
                                Date          = DateTime.Now,
                                OrderNumber   = model.Order.OrderNumber,
                                ReviewContent = cReview.ReviewContent,
                                StarRating    = (short)cReview.StarRating,
                                CourierNumber = cReview.CourierNumber,
                                UserId        = user.Id
                            };

                            db.CourierReviews.Add(review);
                        }
                        else
                        {
                            CourierReview review = db.CourierReviews.Find(cReview.ReviewId);

                            if (review != null)
                            {
                                review.Date          = DateTime.Now;
                                review.ReviewContent = cReview.ReviewContent;
                                review.StarRating    = (short)cReview.StarRating;

                                db.Entry(review).State = System.Data.Entity.EntityState.Modified;
                            }
                        }
                    }
                }

                db.SaveChanges();

                return(RedirectToAction("Index", "Manage"));
            }
        }