public ActionResult Update(Guid id)
{
ProductUpdateVM model = new ProductUpdateVM();
Product itemToBeUpdated = _productService.GetById(id);
model.Product.ID = itemToBeUpdated.ID;
model.Product.Name = itemToBeUpdated.Name;
model.Product.Price = itemToBeUpdated.Price;
model.Product.UnitsInStock = itemToBeUpdated.UnitsInStock;
model.Product.Quantity = itemToBeUpdated.Quantity;
model.Product.ImagePath = itemToBeUpdated.ImagePath;
model.Product.CategoryID = itemToBeUpdated.CategoryID;
model.Product.DisplayOnWeb = itemToBeUpdated.DisplayOnWeb;
model.Product.DisplayOnMobile = itemToBeUpdated.DisplayOnMobile;
//View'e gidecek bu modelin ürün bölümünü tamamladık. Sıra tüm kaktegorileri göndermede.
//Kategorierde direk entity tipinde değil, categoryDTO tipinde olduğu için, select ile atamaları gerçekleştiriyoruz.
//model.Categories = _categoryService.GetActive();
model.Categories = _categoryService.GetActive().Select(c => new CategoryDTO
{
ID = c.ID,
Name = c.Name,
Description = c.Description
}).ToList();
return(View(model));
}
public async Task <IActionResult> Update(int id, ProductUpdateVM productUpdateVM)
{
if (id == 0)
{
return(BadRequest());
}
Car carFromDb = await _context.Cars.FirstOrDefaultAsync(x => x.Id == id);
if (carFromDb == null)
{
return(NotFound());
}
if (!ModelState.IsValid)
{
return(View(productUpdateVM));
}
if (productUpdateVM.MainPhotoFile != null)
{
_image.Delete("files", "cars", carFromDb.PhotoUrl);
carFromDb.PhotoUrl = await _image.UploadAsync(productUpdateVM.MainPhotoFile, "files", "cars");
}
carFromDb.Name = productUpdateVM.Name;
carFromDb.Year = productUpdateVM.Year;
carFromDb.AirConditioner = productUpdateVM.AirConditioner;
carFromDb.GasType = productUpdateVM.GasType;
carFromDb.Gear = productUpdateVM.Gear;
carFromDb.IsActive = productUpdateVM.IsActive;
await _context.SaveChangesAsync();
return(RedirectToAction("Index", "Product"));
}
public async Task <IActionResult> Update(int id)
{
if (id == 0)
{
return(BadRequest());
}
Car carFromDb = await _context.Cars.FirstOrDefaultAsync(x => x.Id == id);
if (carFromDb == null)
{
return(NotFound());
}
ProductUpdateVM productUpdateVM = new ProductUpdateVM
{
Name = carFromDb.Name,
Year = carFromDb.Year,
AirConditioner = carFromDb.AirConditioner,
GasType = carFromDb.GasType,
Gear = carFromDb.Gear,
PhotoUrl = carFromDb.PhotoUrl,
IsActive = carFromDb.IsActive
};
return(View(productUpdateVM));
}
public ActionResult Update(Guid id)
{
ProductUpdateVM model = new ProductUpdateVM();
Product guncellenecek = _productService.GetById(id);
model.Product.ID = guncellenecek.ID;
model.Product.Price = guncellenecek.Price;
model.Product.Name = guncellenecek.Name;
model.Product.Quantity = guncellenecek.Quantity;
model.Product.UnitsInStock = guncellenecek.UnitsInStock;
model.Product.ImagePath = guncellenecek.ImagePath;
model.Product.CategoryID = guncellenecek.CategoryID;
//View'e gidecek bu modelin ürün bölümünü tamamladık, sıra tüm kategorileri göndermede.
//Kategoriler de direk entity tipinde değil CategoryDTO tipinde olduğu için select ile atamaları gerçekleştirdik.
model.Categories = _categoryService.GetActive().Select(c => new CategoryDTO
{
ID = c.ID,
Name = c.Name,
Description = c.Description
}).ToList();
return(View(model));
}
public ActionResult DeleteConfirmed(int id)
{
ProductUpdateVM productUpdateVM = db.ProductUpdateVMs.Find(id);
db.ProductUpdateVMs.Remove(productUpdateVM);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public ActionResult Edit([Bind(Include = "ID")] ProductUpdateVM productUpdateVM)
{
if (ModelState.IsValid)
{
db.Entry(productUpdateVM).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(productUpdateVM));
}
public ActionResult Update(int productId)
{
var model = new ProductUpdateVM
{
Product = _productService.GetById(productId),
Categories = _categoryService.GetAll()
};
return(View(model));
}
public ActionResult Create([Bind(Include = "ID")] ProductUpdateVM productUpdateVM)
{
if (ModelState.IsValid)
{
db.ProductUpdateVMs.Add(productUpdateVM);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(productUpdateVM));
}
public void Update(ProductUpdateVM updateVM)
{
_product.Id = updateVM.Id;
_product.ProductImage = updateVM.ProductImage;
_product.ProductName = updateVM.ProductName;
_product.ProductPrice = updateVM.ProductPrice;
_product.ProductSku = updateVM.ProductSku;
_product.ProductSlug = updateVM.ProductSlug;
_product.CategoryId = updateVM.CategoryId;
_context.Entry(_product).State = EntityState.Modified;
_context.SaveChanges();
}
public IActionResult Update(int id, ProductUpdateVM updateVM)
{
var product = _query.GetById(id);
updateVM.ProductImage = product.ProductImage;
updateVM.ProductName = product.ProductName;
updateVM.ProductPrice = product.ProductPrice;
updateVM.ProductSku = product.ProductSku;
updateVM.ProductSlug = product.ProductSlug;
updateVM.CategoryId = product.CategoryId;
updateVM.Categories = _categoryService.List();
return(View(updateVM));
}
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ProductUpdateVM productUpdateVM = db.ProductUpdateVMs.Find(id);
if (productUpdateVM == null)
{
return(HttpNotFound());
}
return(View(productUpdateVM));
}
public ActionResult Update(int id)
{
ProductUpdateVM model = new ProductUpdateVM();
Product product = _productService.GetById(id);
model.Product.Id = id;
model.Product.Name = product.Name;
model.Product.UnitsInStock = product.UnitsInStock;
model.Product.Quantity = product.Quantity;
model.Product.Price = product.Price;
model.Product.ImagePath = product.ImagePath;
model.Categories = _categoryService.GetActive();
return(View(model));
}
public ActionResult Create([Bind(Include = "UpdateID,UpdateName,UpdateBody,UpdateHeading")] Update update)
{
update.posted = DateTime.Now;
try
{
HttpPostedFileBase file = Request.Files["ImageData"];
ContentRepository service = new ContentRepository();
update = service.UploadImageInDataBase(file, update);
}
catch (System.Data.Entity.Validation.DbEntityValidationException dbEx)
{
Exception raise = dbEx;
foreach (var validationErrors in dbEx.EntityValidationErrors)
{
foreach (var validationError in validationErrors.ValidationErrors)
{
string message = string.Format("{0}:{1}",
validationErrors.Entry.Entity.ToString(),
validationError.ErrorMessage);
// raise a new exception nesting
// the current instance as InnerException
raise = new InvalidOperationException(message, raise);
}
}
throw raise;
}
if (ModelState.IsValid)
{
List <Update> p = new List <Update> {
update
};
var x = new ProductUpdateVM()
{
Updates = p
};
x.Updates.Add(update);
db.ProductUpdateVMs.Add(x);
db.SaveChanges();
return(RedirectToAction("Dash", "ProductUpdateVMs"));
}
return(View(update));
}
public async Task <ActionResult> Put(int id, [FromBody] ProductUpdateVM productUpdateVM)
{
if (id != productUpdateVM.Id)
{
return(BadRequest());
}
var dbproduct = _db.Products.Include(x => x.Category).FirstOrDefault(p => p.Id == id);
if (dbproduct == null)
{
return(NotFound());
}
dbproduct.Name = productUpdateVM.Name;
dbproduct.Description = productUpdateVM.Description;
dbproduct.CategoryId = productUpdateVM.CategoryId;
await _db.SaveChangesAsync();
return(Ok());
}
public ActionResult Update(Guid id)
{
ProductUpdateVM model = new ProductUpdateVM();
Product product = _productService.GetByID(id);
model.Product.Name = product.Name;
model.Product.ID = product.ID;
model.Product.UnitsInStock = product.UnitsInStock;
model.Product.Quantity = product.Quantity;
model.Product.Price = product.Price;
model.Product.ImagePath = product.ImagePath;
model.Product.Director = product.Director;
model.Product.Star = product.Star;
model.Product.Artist = product.Artist;
model.Product.TradeMark = product.TradeMark;
model.Categories = _categoryService.GetActive();
return(View(model));
}
public async Task <IActionResult> Update(ProductUpdateVM updateVM, IFormFile file, string productImage)
{
if (!ModelState.IsValid)
{
return(View(updateVM));
}
updateVM.ProductImage = productImage;
if (file != null)
{
string wwwRootPath = _hostEnvironment.WebRootPath;
string fileName = Path.GetFileNameWithoutExtension(file.FileName);
string extension = Path.GetExtension(file.FileName);
fileName = fileName + DateTime.Now.ToString("yymmssff") + extension;
string path = Path.Combine(wwwRootPath + "/image/", fileName);
using (var fileStream = new FileStream(path, FileMode.Create))
{
await file.CopyToAsync(fileStream);
}
updateVM.ProductImage = fileName;
}
_command.Update(updateVM);
return(RedirectToAction("List"));
}
public ActionResult Create([Bind(Include = "ProdID,ProdBody,ProdName,ProdDesc,ProdShort")] Product product)
{
try
{
HttpPostedFileBase file = Request.Files["ImageData"];
ContentRepository service = new ContentRepository();
product = service.UploadImageInDataBase(file, product, "");
}
catch (System.Data.Entity.Validation.DbEntityValidationException dbEx)
{
Exception raise = dbEx;
foreach (var validationErrors in dbEx.EntityValidationErrors)
{
foreach (var validationError in validationErrors.ValidationErrors)
{
string message = string.Format("{0}:{1}",
validationErrors.Entry.Entity.ToString(),
validationError.ErrorMessage);
// raise a new exception nesting
// the current instance as InnerException
raise = new InvalidOperationException(message, raise);
}
}
throw raise;
}
try
{
HttpPostedFileBase file = Request.Files["ImageDataSplash"];
ContentRepository service = new ContentRepository();
product = service.UploadImageInDataBase(file, product, "ProdSplash");
}
catch (System.Data.Entity.Validation.DbEntityValidationException dbEx)
{
Exception raise = dbEx;
foreach (var validationErrors in dbEx.EntityValidationErrors)
{
foreach (var validationError in validationErrors.ValidationErrors)
{
string message = string.Format("{0}:{1}",
validationErrors.Entry.Entity.ToString(),
validationError.ErrorMessage);
// raise a new exception nesting
// the current instance as InnerException
raise = new InvalidOperationException(message, raise);
}
}
throw raise;
}
try
{
HttpPostedFileBase file = Request.Files["ImageDataPromo"];
ContentRepository service = new ContentRepository();
product = service.UploadImageInDataBase(file, product, "ProdPromo");
}
catch (System.Data.Entity.Validation.DbEntityValidationException dbEx)
{
Exception raise = dbEx;
foreach (var validationErrors in dbEx.EntityValidationErrors)
{
foreach (var validationError in validationErrors.ValidationErrors)
{
string message = string.Format("{0}:{1}",
validationErrors.Entry.Entity.ToString(),
validationError.ErrorMessage);
// raise a new exception nesting
// the current instance as InnerException
raise = new InvalidOperationException(message, raise);
}
}
throw raise;
}
UploadImage(product.ProdBody);
List <Product> p = new List <Product> {
product
};
var x = new ProductUpdateVM()
{
Products = p
};
x.Products.Add(product);
db.ProductUpdateVMs.Add(x);
try
{
db.SaveChanges();
}
catch (System.Data.Entity.Validation.DbEntityValidationException dbEx)
{
Exception raise = dbEx;
foreach (var validationErrors in dbEx.EntityValidationErrors)
{
foreach (var validationError in validationErrors.ValidationErrors)
{
string message = string.Format("{0}:{1}",
validationErrors.Entry.Entity.ToString(),
validationError.ErrorMessage);
// raise a new exception nesting
// the current instance as InnerException
raise = new InvalidOperationException(message, raise);
}
}
throw raise;
}
return(RedirectToAction("Index", "ProductUpdateVMs"));
//return View(product);
}
