Beispiel #1
0
        public FileContentResult GetImage(int ProductID, int width, int height, int imageId = -1)
        {
            Product product = productRepository.products.FirstOrDefault(m => m.ProductID == ProductID);

            if (product != null)
            {
                Domain.Entites.Image image;
                if (imageId == -1)
                {
                    image = product.ImagesWithResolutions.FirstOrDefault().Images.FirstOrDefault(i => i.width == width && i.height == height);
                }
                else if (imageId < 0)
                {
                    return(null);
                }
                else// if (imageId < product.ImagesWithResolutions.Count())
                {
                    ImagesWithResolutions imagesWithResolutions = product.ImagesWithResolutions.FirstOrDefault(i => i.ImagesWithResolutionsID == imageId);
                    image = imagesWithResolutions.Images.FirstOrDefault(i => i.width == width && i.height == height);
                    //.Images.FirstOrDefault(i => i.width == width && i.height == height);
                    // image = null;
                }
                //else
                //{
                //    image = null;
                //}
                if (image != null)
                {
                    return(File(image.ImageData, image.ImageMimeType));
                }
            }
            return(null);
        }
Beispiel #2
0
        public async Task SaveImagesWithResolutions(int ProductID, ImagesWithResolutions imagesWithResolutions)
        {
            // Product product = context.Products.Include(i => i.ImagesWithResolutions).FirstOrDefault( p => p.ProductID == ProductID);
            Product product = context.Products.Include(p => p.ImagesWithResolutions.Select(i => i.Images)).FirstOrDefault();



            if (product != null && product.ImagesWithResolutions.Count() < 12)
            {
                context.Products.Find(ProductID).ImagesWithResolutions.Add(imagesWithResolutions);
                await context.SaveChangesAsync();
            }
        }
Beispiel #3
0
        private ImagesWithResolutions MakeImages(string fileName)
        {
            byte[] image;
            //foreach (FileInfo file in Files)
            ImagesWithResolutions ImagesWithResolutions = new ImagesWithResolutions();

            using (var stream = new FileStream(fileName, FileMode.Open, FileAccess.Read))
            {
                using (var reader = new BinaryReader(stream))
                {
                    image = reader.ReadBytes((int)stream.Length);
                }
            }
            if (image != null)
            {
                System.Drawing.Image tempImage = byteArrayToImage(image);


                ImagesWithResolutions.Images.Add(new Domain.Entites.Image
                {
                    alt           = fileName,
                    ImageData     = this.imageToByteArray(tempImage),
                    ImageMimeType = "image/png",
                    width         = 600,
                    height        = 600
                });
                ImagesWithResolutions.Images.Add(new Domain.Entites.Image
                {
                    alt           = fileName,
                    ImageData     = this.imageToByteArray(tempImage),
                    ImageMimeType = "image/png",
                    width         = 263,
                    height        = 263
                });
                ImagesWithResolutions.Images.Add(new Domain.Entites.Image
                {
                    alt           = fileName,
                    ImageData     = this.imageToByteArray(tempImage),
                    ImageMimeType = "image/png",
                    width         = 60,
                    height        = 60
                });
            }


            return(ImagesWithResolutions);
        }
Beispiel #4
0
        public async Task <ImagesWithResolutions> UpdateImagesWithResolutions(int ProductID, int ImageID, ImagesWithResolutions updatedImagesWithResolutions)
        {
            Product product = context.Products.FirstOrDefault(p => p.ProductID == ProductID);
            ImagesWithResolutions imagesWithResolutions = product.ImagesWithResolutions.FirstOrDefault(i => i.ImagesWithResolutionsID == ImageID);

            if (imagesWithResolutions != null)
            {
                context.Entry(product).Collection("ImagesWithResolutions").Load();
                context.Entry(imagesWithResolutions).Collection("Images").Load();
                for (int i = 0; i < imagesWithResolutions.Images.Count(); i++)
                {
                    await UpdateImage(imagesWithResolutions.Images.ElementAt(i), updatedImagesWithResolutions.Images.ElementAt(i));
                }
                await context.SaveChangesAsync();
            }
            return(imagesWithResolutions);
        }
Beispiel #5
0
        public async Task <ImagesWithResolutions> DeleteImagesWithResolutions(int ProductID, int ImageID)
        {
            Product product = context.Products.FirstOrDefault(p => p.ProductID == ProductID);
            ImagesWithResolutions imagesWithResolutions = product.ImagesWithResolutions.FirstOrDefault(i => i.ImagesWithResolutionsID == ImageID);

            if (imagesWithResolutions != null)
            {
                context.Entry(product).Collection("ImagesWithResolutions").Load();
                context.Entry(imagesWithResolutions).Collection("Images").Load();
                foreach (var image in imagesWithResolutions.Images.ToList())
                {
                    context.Images.Remove(image);
                }
                await context.SaveChangesAsync();

                context.ImagesWithResolutions.Remove(imagesWithResolutions);
                await context.SaveChangesAsync();
            }
            return(imagesWithResolutions);
        }
Beispiel #6
0
        public async Task <ActionResult> Edit(UploadProductViewModel UploadProductViewModel)
        {
            if (ModelState.IsValid)
            {
                ImagesWithResolutions ImagesWithResolutions = new ImagesWithResolutions();

                string[]     Files          = Directory.GetFiles(Server.MapPath("~/temp/"));
                List <State> LStates        = UploadProductViewModel.States.ToList();
                Product      currentProduct = productRepository.products.FirstOrDefault(p => p.ProductID == UploadProductViewModel.Product.ProductID);
                if (currentProduct == null)
                {
                    await productRepository.SaveProduct(UploadProductViewModel.Product);

                    currentProduct = productRepository.products.LastOrDefault();
                }
                List <ImagesWithResolutions> LImagesWithResolutions = currentProduct.ImagesWithResolutions.ToList();
                int CountFiles = 0;

                for (int i = 0; i < LStates.Count(); i++)
                {
                    switch (LStates[i])
                    {
                    case State.add:
                        if (Files.Length > 0 && CountFiles < Files.Length)
                        {
                            deleteTempImg(Files[CountFiles]);
                            await productRepository.SaveImagesWithResolutions(currentProduct.ProductID, MakeImages(Files[CountFiles++]));
                        }

                        break;

                    case State.delete:
                        await productRepository.DeleteImagesWithResolutions(currentProduct.ProductID, currentProduct.ImagesWithResolutions.ElementAt(i).ImagesWithResolutionsID);

                        LStates.RemoveAt(i);
                        --i;
                        break;

                    case State.update:
                        deleteTempImg(Files[CountFiles]);
                        await productRepository.UpdateImagesWithResolutions(currentProduct.ProductID, currentProduct.ImagesWithResolutions.ElementAt(i).ImagesWithResolutionsID, MakeImages(Files[CountFiles++]));

                        break;

                    case State.saved:
                    case State.doNothing:
                    default: break;
                    }
                }



                UploadProductViewModel.Product.ImagesWithResolutions = currentProduct.ImagesWithResolutions;



                await productRepository.SaveProduct(UploadProductViewModel.Product);



                string filePath = Server.MapPath("~/temp/");
                Array.ForEach(Directory.GetFiles(filePath), System.IO.File.Delete);
                UploadProductViewModel.Product = productRepository.products.FirstOrDefault(p => p.ProductID == currentProduct.ProductID);
                if (UploadProductViewModel.Product == null)
                {
                    UploadProductViewModel.Product = productRepository.products.OrderBy(p => p.ProductID).LastOrDefault();
                }
                TempData["message"] = string.Format("Changes in the product \"{0}\" was change!", UploadProductViewModel.Product.Name);
            }


            return(View(UploadProductViewModel));
        }