MyDarling/Controllers/ProductsController.cs

using System.Data;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using MyDarling.Models;
using MyDarling.Services;

namespace MyDarling.Controllers
{
	[Authorize]
	public class ProductsController : Controller
	{
		private DataContext context;
		private IWebHostEnvironment environment;
		private IImageResizer resizer;

		public ProductsController(DataContext context, IImageResizer resizer, IWebHostEnvironment environment)
		{
			this.environment = environment;
			this.context = context;
			this.resizer = resizer;
		}

		public IActionResult Index()
		{
			return View(context.Products.Include(b => b.Figures));
		}

		public IActionResult Create()
		{
			return View();
		}

		[HttpPost]
		public async Task<IActionResult> Create([Bind] Product bundle)
		{
			try
			{
				if (ModelState.IsValid)
				{
					await context.Products.AddAsync(bundle);
					context.SaveChanges();
					return RedirectToAction(nameof(Index));
				}
			}
			catch (DataException)
			{
				ModelState.AddModelError("", "Unable to save changes");
			}
			return View(bundle);
		}

		public async Task<IActionResult> Details(string id)
		{
			return View(await context.Products.Include(b => b.Figures).Where(b => b.Id.Equals(id)).FirstOrDefaultAsync());
		}

		[HttpPost]
		public async Task<IActionResult> Edit(string id)
		{			
			if (string.IsNullOrEmpty(id))
			{
				return NotFound();
			}

			var product = await context.Products.FindAsync(id);
			if (product == null)
			{
				return NotFound();
			}

			var file = Request.Form.Files.FirstOrDefault();
			string fullPath = string.Empty;

			if (await TryUpdateModelAsync<Product>(
				product,
				"",
				b => b.Name, b => b.Description, b => b.Figures, b => b.Price))
			{
				if (file != null)
				{
					var newFigure = new Figure(string.Empty, product.Id);
					product.Figures.Add(newFigure);
					string filePath = $"/Content/{product.Id}/{newFigure.Id}.jpg";
					string directoryPath = environment.WebRootPath + "/Content/" + product.Id + "/";
					fullPath = environment.WebRootPath + filePath;
					if (!Directory.Exists(directoryPath))
					{
						Directory.CreateDirectory(directoryPath);
					}			
					
					resizer.WriteResized(file, fullPath);
				}
				
				if (!string.IsNullOrEmpty(fullPath))
				{					
					resizer.CreateThumbnail(fullPath);
				}

				try
				{
					await context.SaveChangesAsync();
					return RedirectToAction("Details", "Products", new { Id = product?.Id});
				}

				catch (System.Exception)
				{
					ModelState.AddModelError("", "Unable to save changes");
				}
			}
			return View(product);
		}

		[HttpPost]
		public async Task<IActionResult> Delete(string id)
		{
			var productToDelete = await context.Products.FindAsync(id);
			if (productToDelete == null)
			{
				return NotFound();
			}

			try
			{
				var bundleDirPath = String.Concat(environment.WebRootPath,
					"/Content/",
					productToDelete.Id);

				if (Directory.Exists(bundleDirPath))
				{
					Directory.Delete(bundleDirPath, true);
				}
				context.Products.Remove(productToDelete);
				await context.SaveChangesAsync();
				return RedirectToAction(nameof(Index));
			}
			catch (DbUpdateException)
			{
				return RedirectToAction(nameof(Delete), new { id = id, saveChangesError = true });
			}
		}
	}
}