public IEnumerable<ProductViewModel> Create(ProductViewModel product)
    {
        using (var northwind = new Northwind())
        {
            // Create a new Product entity and set its properties from target
            var target = new Product
            {
                ProductName = product.ProductName,
                UnitPrice = product.UnitPrice,
                UnitsInStock = product.UnitsInStock,
                Discontinued = product.Discontinued
            };

            // Add the entity
            northwind.Products.AddObject(target);

            // Insert all created product to the database
            northwind.SaveChanges();

            product.ProductID = target.ProductID;

            // Return the inserted product - the Kendo Grid needs their ProductID which is generated by SQL server during insertion
            return new[] { product };
        }
    }

 public ActionResult Details(ProductViewModel productDetails)
 {
     IEnumerable<Product> lstProduct = null;
     if (!string.IsNullOrEmpty(productDetails.PID))
     {
         lstProduct = ProductService.FindBy(p => p.PID == productDetails.PID);
     }
     else
     {
         productDetails.ToDate = new DateTime(productDetails.ToDate.Year, productDetails.ToDate.Month, productDetails.ToDate.Day, 23, 59, 59);
         if (productDetails.ToDate.Year >= 1900 && productDetails.FromDate.Year >= 1900)
         {
             lstProduct = ProductService.FindBy(p => p.CreatedDate >= productDetails.FromDate && p.CreatedDate <= productDetails.ToDate);
         }
         else if (productDetails.ToDate.Year >= 1900 && productDetails.FromDate.Year <= 1900)
         {
             lstProduct = ProductService.FindBy(p => p.CreatedDate >= DateTime.MinValue && p.CreatedDate <= productDetails.ToDate);
         }
         else if (productDetails.ToDate.Year <= 1900 && productDetails.FromDate.Year >= 1900)
         {
             lstProduct = ProductService.FindBy(p => p.CreatedDate >= productDetails.FromDate && p.CreatedDate <= DateTime.MaxValue);
         }
         else
         {
             lstProduct = ProductService.FindBy(p => p.CreatedDate >= DateTime.MinValue && p.CreatedDate <= DateTime.MaxValue);
         }
     }
     productDetails.lstProducts = lstProduct;
     ViewBag.ResultMessage = lstProduct.Count() == 0 ? "No Record Found" : "";
     return View(productDetails);
 }

 public Product Map(ProductViewModel model)
 {
     return new Product
     {
         Name = model.Name,
     };
 }

        public Action Create(ProductViewModel productViewModel)
        {
            var product = _mapper.Map(productViewModel);
            ShoppingCart cart = _shoppingCartService.AddShoppingCart(product);

            return null;
        }

        /// <summary>
        /// Get Product Information
        /// </summary>
        /// <param name="viewModel"></param>
        /// <returns></returns>
        ///
        /// <summary>
        /// Product Inquiry
        /// </summary>
        /// <param name="viewModel"></param>
        /// <returns></returns>
        public ProductViewModel GetProductInformation(int productID)
        {
            Product product = new Product();
            ProductViewModel productViewModel = new ProductViewModel();

            if (productID == 0)
            {
                List<String> returnMessage = new List<String>();
                returnMessage.Add("An invalid product ID was entered.");
                productViewModel.ReturnMessage = returnMessage;
                productViewModel.ReturnStatus = false;
                return productViewModel;
            }

            ProductDataAccessService productDataAccessService = new ProductDataAccessService();

            product = productDataAccessService.GetProductInformation(productID);
            productViewModel.Product = product;
            productViewModel.ReturnStatus = true;

            if (product.ProductID == 0)
            {
                List<String> returnMessage = new List<String>();
                returnMessage.Add(productID.ToString() + " is not a valid product ID");
                productViewModel.ReturnMessage = returnMessage;
                productViewModel.ReturnStatus = false;
            }

            return productViewModel;
        }

        //
        // GET: /Shop/
        public ActionResult Index()
        {
            if (Session["Cart"] == null) // haven't been to db yet
            {
                try
                {
                    ProductViewModel prod = new ProductViewModel();
                    List<ProductViewModel> Prods = prod.GetAll();
                    if (Prods.Count() > 0)
                    {
                        CartItem[] myCart = new CartItem[Prods.Count]; // array
                        int ctr = 0;

                        // build CartItem array from List contents
                        foreach (ProductViewModel p in Prods)
                        {
                            CartItem item = new CartItem();
                            item.ProdCd = p.ProdCode;
                            item.ProdName = p.ProdName;
                            item.Graphic = p.Graphic;
                            item.Msrp = p.Msrp;
                            item.Description = p.Description;
                            item.Qty = 0;
                            myCart[ctr++] = item;
                        }
                        Session["Cart"] = myCart;  // load to session
                    }
                }
                catch (Exception ex)
                {
                    ViewBag.Message = "Catalogue Problem - " + ex.Message;
                }
            }
            return View();
        }

        public ActionResult Index()
        {
            var productViewModel = new ProductViewModel();
            productViewModel.Products = _productService.GetAllProducts().ToList();

            return View(productViewModel);
        }

        public async Task<ActionResult> ProductList()
        {
            try
            {
                ParseQuery<ParseObject> query = ParseObject.GetQuery("Product");
                IEnumerable<ParseObject> productList = await query.FindAsync();

                List<ProductViewModel> _productList = new List<ProductViewModel>();

                foreach (ParseObject p in productList)
                {

                    ProductViewModel model = new ProductViewModel(p);
                    ParseQuery<ParseObject> q = ParseObject.GetQuery("Specification");
                    ParseObject specification = await q.GetAsync(model.specification.specificationId);
                    
                }

                return View();
            }
            catch (ParseException pe)
            {
                return View();
            }
        }

        public ProductViewModel DefaultBrickData()
        {
            ProductViewModel productViewModel = new ProductViewModel();
            productViewModel.Products = new List<ProductEntity>();

            for (int i = 1; i < 8; i++)
            {
                var product = new ProductEntity();
                product.Id = i;
                if(i%2 == 0)
                {
                    product.Name = "Antique Stratford";
                    product.Description = "A look of modern elegance; Antique Stratford has a deep maroon body with a soft splash of white accent.";
                    product.SampleImagePath = "brickSample.png";
                    product.Images = new List<string>
                                         {"AntiqueStratford_1.jpg", "AntiqueStratford_2.jpg", "AntiqueStratford_3.jpg"};
                }
                else
                {
                    product.Name = "Cambridge";
                    product.Description = "Cambridge is a traditional deep red brick boasting a uniform color with a classic marbled texture.";
                    product.SampleImagePath = "brickSample.png";
                    product.Images = new List<string> { "Cambridge_1.jpg", "Cambridge_2.jpg", "Cambridge_3.jpg" };
                }

                productViewModel.Products.Add(product);

            }

            return productViewModel;
        }

 /// <summary>
 /// Добавление курса в репозиторий
 /// </summary>
 /// <param name="product"></param>
 public void Add(ProductViewModel product)
 {
     product.CreatedDate = product.UpdatedDate = DateTime.Now;
     if (product.AssignedUserId == 0)
         product.AssignedUserId = null;
     productRepository.Add(ConvertFromProductViewModelToProduct(product));
 }

        public ActionResult Details(string code)
        {
            RestClient<Product> productsRestClient = new RestClient<Product>("http://localhost:3001/");
            var product = productsRestClient.Get("products/code/" + code).Result;

            // TODO: Fix this in EF
            product.Supplier = new Supplier
            {
                Id = product.SupplierId,
                Name = "My Supplier"
            };

            var productViewModel = new ProductViewModel()
            {
                Id = product.Id,
                Code = product.Code,
                Name = product.DisplayName,
                Price = product.UnitPrice,
                SupplierName = product.Supplier.Name
            };

            ProductViewModel another = Mapper.Map<ProductViewModel>(product);

            return View(another);
        }

 public ActionResult Products_Update([DataSourceRequest]DataSourceRequest request, ProductViewModel product)
 {
     if (ModelState.IsValid)
     {
         using (var northwind = new NorthwindEntities())
         {
             // Create a new Product entity and set its properties from the posted ProductViewModel
             var entity = new Product
             {
                 ProductID = product.ProductID,
                 ProductName = product.ProductName,
                 UnitsInStock = product.UnitsInStock
             };
             // Attach the entity
             northwind.Products.Attach(entity);
             // Change its state to Modified so Entity Framework can update the existing product instead of creating a new one
             northwind.Entry(entity).State = EntityState.Modified;
             // Or use ObjectStateManager if using a previous version of Entity Framework
             // northwind.ObjectStateManager.ChangeObjectState(entity, EntityState.Modified);
             // Update the entity in the database
             northwind.SaveChanges();
         }
     }
     // Return the updated product. Also return any validation errors.
     return Json(new[] { product }.ToDataSourceResult(request, ModelState));
 }

        public static List<ProductViewModel> ProductListToProductViewModelList(List<Product> products, int userId, Vote vote)
        {
            List<ProductViewModel> prods = new List<ProductViewModel>();

            int votedProductId = 0;
            if (vote != null)
            {
               votedProductId  = vote.ProductId;
            }

            foreach (var item in products)
            {
                ProductViewModel prod = new ProductViewModel();
                prod.Id = item.Id;
                prod.Name = item.Name;
                prod.Description = item.Description;
                prod.ImagePath = item.ImagePath;
                prod.VotesAmount = (item.Votes != null) ? item.Votes.Count() : 0;
                prod.ButtonClass = (item.Id == votedProductId) ? EnumDescription.GetEnumDescription(ButtonClass.Voted) : EnumDescription.GetEnumDescription(ButtonClass.Default);
                prod.EditActionLink = "/Home/Edit/" + item.Id;
                prods.Add(prod);
            }

            return prods;
        }

        public async Task<ActionResult> Details(int? id)
        {
            if (id == null)
            {
                return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
            }
            var product  = await _db.Products.Where(p => p.ProductId == id).Include(p => p.SoftwarePolicy).Include(p => p.ProductCategory).Include(p => p.ProductType).Include(p => p.LocalAccountVerification).Include(p => p.ProductsPermissions).FirstOrDefaultAsync();
            if (product == null)
            {
                return HttpNotFound("Unable to retrieve the selected product");
            }
            var productViewModel = new ProductViewModel(product);

            if (ContainsInvalid(productViewModel.Version))
            {
                ViewBag.DetailTitle = productViewModel.Name;
            }
            else if (productViewModel.Name.Contains(productViewModel.Version))
            {
                ViewBag.DetailTitle = productViewModel.Name;
            }
            else
            {
                ViewBag.DetailTitle = $"{productViewModel.Name} {productViewModel.Version}";
            }
            return View(productViewModel);
        }

        public ActionResult About( int? id)
        {
            if (User.Identity.GetUserId() != null)
            {
                var productRepository = new ProductRepository();
                var pvm = new ProductViewModel();

                var gpab = productRepository.GetPeopleAlsoBought(id);

                pvm.PeopleAlsoBought = gpab;
                var idprod = productRepository.GetProductDetails(id);

                pvm.LargePhoto = idprod.LargePhoto;
                pvm.listPrice = idprod.listPrice;
                pvm.Name = idprod.Name;
                pvm.ProductId = idprod.ProductId;
                pvm.color = idprod.color;
                pvm.Weight = idprod.Weight;
                pvm.size = idprod.size;
                pvm.description = idprod.description;
                ViewBag.Message = "Your application description page.";

                return View(pvm);
            }
            else
            {
                return RedirectToAction("Login", "Account");
            }
        }

        public ActionResult AddOrEditNewProduct(ProductViewModel product)
        {
            if (string.IsNullOrEmpty(product.Name))
                ModelState.AddModelError("Name", "Ange produktens namn");

            if ((product.Prices == null || product.Prices.Count < 1) || product.Prices.First().Price == 0)
                ModelState.AddModelError("Prices", "Ange ett pris");

            if (ModelState.IsValid)
            {
                var p = ProductHelper.ViewModelToModel(product);

                //Take a maximum of 5 prices
                p.Prices = p.Prices.Where(pr => pr.Price > 0).Take(5).ToList();

                if (product.Id != null && Db.Products.GetProductById(product.Id) != null)
                {
                    //if product isnot xatly the same!update
                    Db.Products.UpdateProduct(p, product.Enterprise);
                    return Json(new { success = true, method = "update" });
                }

                Db.Products.AddProduct(p, product.CategoryId, product.Enterprise);
                return Json(new { success = true, method = "add" });
            }

            return PartialView("~/Views/Partials/Menu/Edit/_Product.cshtml", product);
        }

        public override ActionResult Index(RenderModel model)
        {
            var products = model.Content.Children();
            var viewModel = new ProductFolderViewModel();
            
            foreach (var productContent in products)
            {
                var productModel = new ProductViewModel();

                productModel.Content= productContent.GetPropertyValue<string>("bodyText")
                    .ScrubHtml()
                    .Truncate(200, true, true);

                productModel.UrlName = productContent.UrlName;
                productModel.Title = productContent.Name;
                productModel.NumberOfComments = productContent.Descendants("Comment").Count();
                viewModel.Products.Add(productModel);
            }

            if (Request.IsAjaxRequest())
            {
                return Json(viewModel);
            }

            ViewBag.Model = viewModel;
            
            //Do some stuff here, then return the base method
            return base.Index(model);
        }

        public ActionResult ProductCreate(ProductViewModel firstModel, StorageViewModel secondModel)
        {
            try
            {
                var product = new ProductBusinessModel()
                {
                    Name = firstModel.Name,
                    Price = firstModel.Price,
                    StatusCode = firstModel.StatusCode
                };
                _productBl.Add(product);

                var storage = new StorageBusinessModel()
                {
                    ProductId = product.Id,
                    Quantity = secondModel.Quantity
                };
                _storageBl.Add(storage);

                return RedirectToAction("ProductIndex");
            }
            catch
            {
                return View("Error");
            }
        }

        public ActionResult Index(string permalink)
        {
            /* var blogDAC = new BlogDAC();
            List<BlogDTO> blogs = new List<BlogDTO>();
            BlogViewModels blogModels = new BlogViewModels();
            blogModels.Blogs = new List<BlogViewModel>();
            blogs = blogDAC.ReadAllBlogs();
            foreach (var blogDto in blogs)
            {
                var blogModel = new BlogViewModel();
                blogModel.Description = blogDto.Description;
                blogModels.Blogs.Add(blogModel);
            }*/

            var productDAC = new ProductDAC();
            List<IProductDTO> products = new List<IProductDTO>();
            ProductViewModel blogModels = new ProductViewModel();
            blogModels.Products = new List<ProductItemViewModel>();
            products = productDAC.ReadAllProducts();
            foreach (var blogDto in products)
            {
                var blogModel = new ProductItemViewModel();
                blogModel.Description = blogDto.Description;
                blogModel.Name = blogDto.Name;
                blogModel.SeoTitle = blogDto.SeoTitle;
                blogModel.ImageURL = blogDto.ImageURL;

                blogModels.Products.Add(blogModel);
            }

            return View(blogModels);
        }

        public async Task<ActionResult> ProductList()
        {
            try
            {
                ParseQuery<ParseObject> query = ParseObject.GetQuery("Product");
                IEnumerable<ParseObject> products = await query.FindAsync();

                List<ProductViewModel> _products = new List<ProductViewModel>();

                foreach (ParseObject p in products)
                {
                    ProductViewModel product = new ProductViewModel(p);

                    // Get specification from product
                    Specification sp = new Specification(await p.Get<ParseObject>("specification").FetchIfNeededAsync());

                    // Add specification into product model
                    product.setSpecification(sp);

                    _products.Add(product);
                }

                return View(_products);
            }
            catch (ParseException)
            {
                return View();
            }
        }