// GET: Products/Edit/5
public ActionResult Edit(int?id)
{
EditProductViewModel model = new EditProductViewModel();
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Product product = db.Products.Find(id);
if (product == null)
{
return(HttpNotFound());
}
model.ID = product.ID;
model.Name = product.Name;
model.Description = product.Description;
model.OriginalPrice = product.OriginalPrice;
model.SellingPrice = product.SellingPrice;
model.stock = product.stock;
model.CategoryID = product.Category != null ? product.Category.ID : 0;
model.ImageURL = product.ImageURL;
model.Tags = product.Tags;
model.AvailableCategories = db.Categories.ToList();
return(View(model));
}
public Product EditProduct(EditProductViewModel model)
{
var editProduct = vATUShopDbContext.Products.Find(model.ProductId);
editProduct.ProductName = model.ProductName;
editProduct.CategoryId = model.CategoryId;
editProduct.BrandId = model.BrandingId;
editProduct.Price = model.Price;
editProduct.Inventory = model.Inventory;
editProduct.Description = model.Description;
editProduct.ImagePath = model.ImagePath;
string fileName = null;
if (model.Image != null)
{
string uploadFolder = Path.Combine(webHostEnvironment.WebRootPath, "img");
fileName = $"{Guid.NewGuid()}_{model.Image.FileName}";
var filePath = Path.Combine(uploadFolder, fileName);
using (var fs = new FileStream(filePath, FileMode.Create))
{
model.Image.CopyTo(fs);
}
editProduct.ImagePath = fileName;
if (!string.IsNullOrEmpty(model.ImagePath) && (model.ImagePath != "none-avatar.png"))
{
string delFile = Path.Combine(webHostEnvironment.WebRootPath
, "img", model.ImagePath);
System.IO.File.Delete(delFile);
}
}
vATUShopDbContext.SaveChanges();
return editProduct;
}
public IActionResult Edit(string id)
{
ViewBag.Categories = categoryRepository.Get();
ViewBag.Brands = brandRepository.Get();
var product = productRepository.Get(id);
ViewBag.Images = (from e in context.Images
where e.ProductId == product.ProductId
select e).ToList();
if (product == null)
{
return(View("~/Views/Error/PageNotFound.cshtml"));
}
var editProduct = new EditProductViewModel
{
BrandId = product.BrandId,
CategoryId = product.CategoryId,
CPU = product.CPU,
Description = product.Description,
FrontCamera = product.FrontCamera,
//ImageFileName = product.ImageFileName,
Name = product.Name,
OS = product.OS,
Price = product.Price,
ProductId = product.ProductId,
Ram = product.Ram,
RearCamera = product.RearCamera,
Remain = product.Remain,
Rom = product.Rom,
Screen = product.Screen
};
return(View(editProduct));
}
public async Task <IActionResult> ChangePicture(EditProductViewModel model)
{
if (model.Id == null || model.Pictures == null)
{
TempData[GlobalConstants.TempDataErrorMessageKey] = GlobalConstants.InvalidData;
return(this.RedirectToAction("Edit", new { id = model.Id }));
}
var currentPicture = _pictureService.GetProductPicturesById(model.Id);
var entityType = typeof(Product);
var productPictureId = string.Format(GlobalConstants.ProductPicture, model.Name);
//Delete the old picture from cloudinary
_pictureService.DeletePicture(entityType, currentPicture.Id);
//Delete old picture from DB
DeletePictureFromDB(currentPicture);
//Add new picture to Cloudinary
var pictures = new List <IFormFile>();
pictures.Add(model.Pictures.First());
await this._pictureService.UploadPicturesAsync(pictures, entityType, productPictureId, model.Id);
return(Redirect("/"));
}
public void ShowWindow(BaseViewModel viewModel, bool showAsDialog = false)
{
Window window = viewModel switch
{
// Wenn viewModel null ist -> ArgumentNullException
null => throw new ArgumentNullException(nameof(viewModel)),
MainWindowViewModel _ => new MainWindow(),
EditProductViewModel _ => new EditProductWindow(),
// default -> InvalidOperationException
_ => throw new InvalidOperationException($"Unbekanntes ViewModel '{viewModel}'"),
};
_windows[viewModel] = window;
window.DataContext = viewModel;
if (showAsDialog)
{
window.ShowDialog();
}
else
{
window.Show();
}
}
public ResultViewModel Put([FromBody] EditProductViewModel model)
{
model.Validate();
if (model.Invalid)
{
return new ResultViewModel
{
Success = false,
Message = "Não foi possível alterar o produto!",
Data = model.Notifications
}
}
;
Product product = _context.Products.Find(model.Id);
product.Title = model.Title;
product.CategoryId = model.CategoryId;
product.Descriptions = model.Description;
product.Image = model.Image;
product.LastUpdateDate = DateTime.Now;
product.Price = model.Price;
product.Quantity = model.Quantity;
_context.Entry <Product>(product).State = EntityState.Modified;
_context.SaveChanges();
return(new ResultViewModel
{
Success = true,
Message = "Produto alterado com sucesso!",
Data = product
});
}
}
public async Task <IActionResult> Edit(int id)
{
var product = await _dbContext.Products
.Include(u => u.ApplicationUser)
.Where(p => p.Id == id)
.FirstOrDefaultAsync();
if (product == null)
{
return(new NotFoundResult());
}
var authorizationResult = await _authorizationService
.AuthorizeAsync(User, product, CRUD.Update);
if (authorizationResult.Succeeded)
{
EditProductViewModel model = new EditProductViewModel {
Id = product.Id,
Name = product.Name,
Description = product.Description,
Price = product.Price
};
return(View(model));
}
else if (User.Identity.IsAuthenticated)
{
return(new ForbidResult());
}
else
{
return(new ChallengeResult());
}
}
public virtual ActionResult Edit(EditProductViewModel viewModel) // changes an entity redirects to list
{
if (!ModelState.IsValid)
{
ModelState.AddModelError("", "فیلدهای مورد نظر را وارد کنید.");
return(View(viewModel));
}
try
{
ServiceFactory.Create <IProductService>()
.Save(new Product
{
Id = viewModel.Id,
Name = viewModel.Name,
Code = viewModel.Code,
Description = viewModel.Description,
CategoryId = viewModel.CategoryId,
Version = viewModel.Version,
Price = viewModel.Price
});
}
catch (DbUpdateConcurrencyException)
{
ModelState.AddModelError("", "کالا مورد نظر توسط کاربر دیگری در شبکه، تغییر یافته است. برای ادامه صفحه را رفرش کنید.");
return(View(viewModel));
}
return(RedirectToAction("List"));
}
public async Task <IActionResult> Edit(EditProductViewModel vm)
{
if (ModelState.IsValid)
{
var input = new BLLProductDTO
{
Id = vm.ProductId,
OrganizationId = vm.OrganizationId,
Description = vm.Description,
CurrentPrice = vm.Price,
ProductName = vm.ProductName,
Categories = vm.SelectedCategories.Select(i => new BLLCategoryMinDTO(i)).ToList()
};
var result = await _bll.ProductService.EditProduct(input);
if (result == false)
{
return(BadRequest("Edit unsuccessful"));
}
return(RedirectToAction("Organization", "Dashboard", new { Id = vm.OrganizationId }));
}
var categories =
(await _bll.OrganizationsService.GetOrganizationWithCategoriesAsync(vm.OrganizationId)).Categories;
vm.Categories = categories.Select(dto =>
new SelectListItem(dto.CategoryName, dto.CategoryId.ToString(), vm.SelectedCategories.Contains(dto.CategoryId)))
.ToList();
return(View(vm));
}
public ActionResult Edit(EditProductViewModel model)
{
if (ModelState.IsValid)
{
var existingProduct = ProductsService.Instance.GetProduct(model.ID);
existingProduct.Name = model.Name;
existingProduct.Description = model.Description;
existingProduct.Price = model.Price;
existingProduct.Category = null; //mark it null. Because the referncy key is changed below
existingProduct.CategoryID = model.CategoryID;
//dont update imageURL if its empty
if (!string.IsNullOrEmpty(model.ImageURL))
{
existingProduct.ImageURL = model.ImageURL;
}
ProductsService.Instance.UpdateProduct(existingProduct);
return(RedirectToAction("ProductTable"));
}
else
{
return(new HttpStatusCodeResult(500));
}
}
public async Task <IActionResult> Edit(int?id)
{
if (id == null)
{
return(NotFound());
}
var product = await _bll.ProductService.GetProductAsync(productId : id.Value);
if (product == null)
{
return(NotFound());
}
var categories =
(await _bll.OrganizationsService.GetOrganizationWithCategoriesAsync(product.OrganizationId)).Categories;
var selectedCategoryIds = product.Categories.Select(dto => dto.Id).ToList();
var vm = new EditProductViewModel()
{
Price = product.CurrentPrice,
Description = product.Description,
ProductId = product.Id,
OrganizationId = product.OrganizationId,
ProductName = product.ProductName,
Categories = categories.Select(dto =>
new SelectListItem(dto.CategoryName, dto.CategoryId.ToString(), selectedCategoryIds.Contains(dto.CategoryId)))
.ToList()
};
vm.Categories.Sort((item, item2) => int.Parse(item.Value).CompareTo(int.Parse(item2.Value)));
return(View(vm));
}
//Edit Product GetFunction
public ActionResult Edit(int id)
{
EditProductViewModel model = new EditProductViewModel();
using (ApplicationDbContext _context = new ApplicationDbContext())
{
var product = _context.Products.Include(x => x.Category).Include(x => x.Companies)
.Include(x => x.ProductStockList).Include(x => x.productOrderDetailList)
.Include(x => x.ProductImages).Where(x => x.ID == id)
.SingleOrDefault();
model.ID = product.ID;
model.ProductName = product.ProductName;
model.IsFeatured = product.IsFeatured;
model.ProductDescription = product.ProductDescription;
model.CategoryId = product.Category != null ? product.Category.Id : 0;
model.Category = _context.Categories.Where(x => x.IsActive == true).ToList();
model.CompanyId = product.Companies != null ? product.Companies.Id : 0;
model.Companies = _context.Companieses.Where(x => x.isDeleted != true).ToList();
model.salePrice = product.salePrice;
model.purchasePrice = product.purchasePrice;
model.Quantity = product.ProductStockList.Sum(x => x.productUpdatedQuantity) -
product.productOrderDetailList.Sum(s => s.Quantity);
model.ProductImages = product.ProductImages;
}
return(View(model));
}
public ActionResult Edit(EditProductViewModel vm, HttpPostedFileBase file = null)
{
int productID = (Session["productId"]) != null ? (int)Session["productId"] : 0;
var product = repository.GetProductById(productID);
if (ModelState.IsValid)
{
if (file != null)
{
vm.ImageData = convertToByteArray(file);
product.ImageMimeType = file.ContentType;
product.ImageData = vm.ImageData;
}
product.Name = vm.Name;
product.Description = vm.Description;
product.Category = vm.Category.ToString();
product.ProductColour = vm.ProductColour;
product.Price = vm.Price;
repository.SaveChanges();
TempData["message"] = string.Format($"{product.Name} has been saved");
return(RedirectToAction("Index"));
}
else
{
return(View(vm));
}
}
public async Task <ActionResult> Edit(EditProductViewModel product)
{
var command = new ChangePrice(product.Id, product.Price);
await _productService.ExecuteAsync(command);
return(RedirectToAction("Index"));
}
// GET: Product/Edit/5
public async Task <IActionResult> Edit(int?id)
{
string userid = User.FindFirstValue(ClaimTypes.NameIdentifier);
Klant klant = _context.Klanten.FirstOrDefault(k => k.UserId == userid);
if (id == null)
{
return(NotFound());
}
var product = await _context.Producten.Include(p => p.Productregels).
SingleOrDefaultAsync(x => x.ProductId == id);
if (product == null)
{
return(NotFound());
}
EditProductViewModel viewModel = new EditProductViewModel
{
Product = product,
Ingredientenlijst = new SelectList(_context.Ingredienten, "IngredientId", "Soort"),
GeselecteerdeIngredienten = product.Productregels.Select(pr => pr.IngredientId)
};
return(View(viewModel));
}
public EditProductViewModel Create(int id)
{
EditProductViewModel viewModel = new EditProductViewModel();
viewModel.UpdateProductModel = new UpdateProductModel();
var productDetails = getProductDetailsQuery.Execute(id);
viewModel.ProductDetailsModel = productDetails;
viewModel.UpdateProductModel.ProductID = productDetails.ProductID;
viewModel.UpdateProductModel.ProductName = productDetails.ProductName;
viewModel.UpdateProductModel.ProductTypeCode = productDetails.ProductTypeCode;
viewModel.UpdateProductModel.OtherDetails = productDetails.OtherDetails;
viewModel.UpdateProductModel.ProductDescription = productDetails.ProductDescription;
viewModel.UpdateProductModel.ReorderLevel = productDetails.ReorderLevel;
viewModel.UpdateProductModel.ReorderQuantity = productDetails.ReorderQuantity;
viewModel.UpdateProductModel.UnitPrice = productDetails.UnitPrice;
var productTypesList = getProductTypesListQuery.Execute();
viewModel.productTypesList = productTypesList.Select(p => new SelectListItem()
{
Value = p.ProductTypeCode.ToString(),
Text = p.ProductTypeDescription.ToString()
})
.ToList();
return(viewModel);
}
void prepareEditModel(EditProductViewModel model, int id)
{
PrepareViewModel(model, EvolutionResources.bnrAddEditProduct + (model.Product.Id > 0 ? " - " + model.Product.ItemName : ""), id, MakeMenuOptionFlags(0, 0, 0, 0, model.Product.Id) + MenuOptionFlag.RequiresNewProduct);
model.ProductAvailabilityList = LookupService.FindLOVItemsListItemModel(CurrentCompany, LOVName.ProductAvailability);
model.MaterialList = LookupService.FindLOVItemsListItemModel(CurrentCompany, LOVName.Material);
model.ABList = LookupService.FindLOVItemsListItemModel(CurrentCompany, LOVName.AB);
model.UserList = MembershipManagementService.FindUserListItemModel();
model.ProductStatusList = new List <ListItemModel>();
foreach (var item in LookupService.FindLOVItemsModel(null, LOVName.ProductStatus))
{
model.ProductStatusList.Add(new ListItemModel {
Id = item.ItemValue1, Text = item.ItemText
});
}
model.WebCategoryList = LookupService.FindLOVItemsListItemModel(CurrentCompany, LOVName.WebCategory);
model.WebSubCategoryList = LookupService.FindLOVItemsListItemModel(CurrentCompany, LOVName.WebSubCategory);
model.MediaPath = MediaServices.GetProductImageFolder(true);
var bc = new Evolution.BarCodeService.BarCodeService(db);
model.Product.BarCodeFile1 = bc.GetBarCode(model.Product.BarCode, true);
model.Product.BarCodeFile2 = bc.GetBarCode(model.Product.InnerBarCode, true);
model.Product.BarCodeFile3 = bc.GetBarCode(model.Product.MasterBarCode, true);
}
public virtual ActionResult Edit(long?id) // returns the viewmodel doesn't change anything
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
EditProductViewModel viewModel = ServiceFactory.Create <IProductService>()
.FetchByIdAndProject(id.Value, a => new EditProductViewModel
{
Id = a.Id,
CategoryId = a.CategoryId,
Code = a.Code,
Description = a.Description,
Name = a.Name,
Price = a.Price,
Version = a.Version
});
if (viewModel == null)
{
return(HttpNotFound());
}
return(View(viewModel));
}
public ActionResult CreateProduct(EditProductViewModel product)
{
//if (product.Price < 0)
//{
// ModelState.AddModelError(string.Empty, "Preis darf nicht kleiner als Null sein");
// product.Price = db.Products.Find(product.ID).Price;
// return View(product);
//}
if (Session["Admin"] == null)
{
return(RedirectToAction("Login"));
}
if (ModelState.IsValid)
{
Product p = new Product
{
Name = product.Name,
CategoryID = product.SelectedCategoryID,
IsInSortiment = product.IsInSortiment,
Price = product.Price
};
db.Products.Add(p);
db.SaveChanges();
return(RedirectToAction("ListProducts"));
}
else
{
ModelState.AddModelError(string.Empty, "Ungültige Daten");
}
return(View(product));
}
public ResultViewModel Post([FromBody] EditProductViewModel model)
{
model.Validate();
if (model.Invalid)
{
return new ResultViewModel
{
Success = false,
Message = "Não foi possível cadastrar o produto!",
Data = model.Notifications
}
}
;
Product product = new Product();
product.Title = model.Title;
product.CategoryId = model.CategoryId;
product.CreateDate = DateTime.Now; //nunca recebe esta informação é automática
product.Descriptions = model.Description;
product.Image = model.Image;
product.LastUpdateDate = DateTime.Now; // nunca recebe esta informação é automática
product.Price = model.Price;
product.Quantity = model.Quantity;
_context.Products.Add(product);
_context.SaveChanges();
return(new ResultViewModel
{
Success = true,
Message = "Produto Cadastrado com sucesso!",
Data = product
});
}
public async Task <IActionResult> Edit(EditProductViewModel editProductViewModel)
{
if (!this.ModelState.IsValid)
{
return(this.View(editProductViewModel));
}
try
{
await this.catalogService.EditProduct(editProductViewModel);
return(this.RedirectToAction(nameof(Index), new { currentPage = editProductViewModel.FromPageNumber }));
}
catch (Refit.ApiException apiEx)
{
if (apiEx.HasContent)
{
JsonConvert
.DeserializeObject <List <string> >(apiEx.Content)
.ForEach(error => this.ModelState.AddModelError(string.Empty, error));
}
else
{
this.ModelState.AddModelError(string.Empty, ErrorConstants.InternalServerErrorMessage);
}
this.HandleException(apiEx);
}
return(this.View(editProductViewModel));
}
public ActionResult AddProduct(int?productVariantId, bool?confirm)
{
ProductVariant productVariant;
if (productVariantId.HasValue)
{
ViewBag.EditMode = true;
productVariant = db.ProductsVariant.Find(productVariantId);
}
else
{
ViewBag.EditMode = false;
productVariant = new ProductVariant();
}
var result = new EditProductViewModel();
result.Product = db.Products.ToList();
result.Size = db.Sizes.ToList();
result.Color = db.Colors.ToList();
result.ProductVariant = productVariant;
result.Confirm = confirm;
return(View(result));
}
public async Task <IActionResult> Create(string evtSlug)
{
var evt = await _dbContext.Events.SingleOrDefaultAsync(x => x.Slug == evtSlug);
var user = await _userManager.GetUserAsync(User);
if (evt == null)
{
_logger.LogInformation("Could not find event with slug '{slug}'", evtSlug);
return(RedirectToAction("Index", "Events"));
}
if (!(await _authorizationService.AuthorizeAsync(User, evt, Policies.EventAdmin)).Succeeded)
{
return(Forbid());
}
var model = new EditProductViewModel
{
EventId = evt.Id,
EventSlug = evt.Slug,
EventName = evt.Name
};
if (evt.DefaultMinimumBidAmount.HasValue)
{
model.MinimumBidAmount = evt.DefaultMinimumBidAmount.Value;
}
return(View(model));
}
public ActionResult EditProduct(int id)
{
AppDbContext dbContext = new AppDbContext();
ProductModels product = dbContext.getProducts.SingleOrDefault(p => p.Id == id);
ModelModels model = dbContext.getModels.SingleOrDefault(m => m.Id == product.ModelId);
List <BrandModels> brands = dbContext.getBrands.ToList();
List <CategoryModels> categories = dbContext.getCategories.ToList();
List <ProductPhoto> photos = dbContext.getProductPhotos(product.Id).ToList();
List <ModelModels> models = dbContext.getModelBrands(model.BrandId).ToList();
EditProductViewModel viewModel = new EditProductViewModel
{
Id = product.Id,
Models = models,
ModelId = product.ModelId,
Brands = brands,
BrandId = product.BrandId,
Categories = categories,
CategoryId = product.CategoryId,
Price = product.Price,
Color = product.Color,
Storage = product.Storage,
Processor = product.Processor,
Memory = product.Memory,
Display = product.Display,
Details = product.Details,
CreatedBy = product.CreatedBy,
CreatedDate = product.CreatedDate,
Photos = photos
};
return(View(viewModel));
}
public ResultViewModel Post([FromBody] EditProductViewModel model)
{
model.Validate();
if (model.Invalid)
{
return(new ResultViewModel
{
Success = false,
Message = "Não foi possível cadastrar o produto.",
Data = model.Notifications
});
}
var product = new Product();
product.Title = model.Title;
product.CategoryId = model.CategoryId;
product.Description = model.Description;
product.Image = model.Image;
product.Price = model.Price;
product.Quantity = model.Quantity;
product.CreateDate = DateTime.Now;
product.LastUpdateDate = DateTime.Now;
_repository.Save(product);
return(new ResultViewModel
{
Success = true,
Message = "Produto cadastrado com sucesso!",
Data = product
});
}
public ActionResult Edit(EditProductViewModel model)
{
if (ModelState.IsValid)
{
var existingProduct = db.Products.Find(model.ID);
existingProduct.Name = model.Name;
existingProduct.Description = model.Description;
existingProduct.OriginalPrice = model.OriginalPrice;
existingProduct.SellingPrice = model.SellingPrice;
existingProduct.stock = model.stock;
existingProduct.Category = null; //mark it null. Because the referncy key is changed below
existingProduct.CategoryID = model.CategoryID;
//existingProduct.Category = db.Categories.Find(model.CategoryID);
existingProduct.Tags = model.Tags;
existingProduct.UpdatedOn = DateTime.Now;
//don't update imageURL if its empty
if (!string.IsNullOrEmpty(model.ImageURL))
{
existingProduct.ImageURL = model.ImageURL;
}
db.Entry(existingProduct).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(model));
}
public IActionResult Edit(int id)
{
Product product = unitOfWork.Products.GetById(id);
if (product == null)
{
ErrorViewModel errorVM = new ErrorViewModel
{
RequestId = "Product Not Found"
};
return(View("Error", errorVM));
}
if (User.Identity.IsAuthenticated)
{
cartItems = unitOfWork.CartItems.GetUserCartItems(User.FindFirst(ClaimTypes.NameIdentifier).Value).ToList();
}
EditProductViewModel productVM = new EditProductViewModel(categories, cartItems)
{
Product = unitOfWork.Products.GetProductWithRelatives(id),
PaymentMethods = unitOfWork.Payments.GetAll().ToList(),
tags = new List <Tag>()
};
//ProductsTags[] productTags = productVM.Product.ProductsTags.ToArray();
ProductsTags[] productTags = unitOfWork.ProductTag.GetAll().Where(pt => pt.ProductID == id).Include(p => p.Tag).ToArray();
for (int i = 0; i < productTags.Count(); i++)
{
productVM.tags.Append(productTags[i].Tag);
}
return(View(productVM));
}
public int EditProduct(EditProductViewModel model)
{
var edit = GetProduct(model.Id);
edit.NameProduct = model.NameProduct;
edit.Price = model.Price;
edit.ProductId = model.Id;
edit.Description = model.AddDescription;
edit.CategoryId = model.CategoryId;
string FileImage = null;
if (model.AvataPast != null)
{
if (!string.IsNullOrEmpty(edit.Avata) && (edit.Avata != "none-avatar.png"))
{
string delFile = Path.Combine(webHost.WebRootPath, "images", edit.Avata);
System.IO.File.Delete(delFile);
}
string uploadsFolder = Path.Combine(webHost.WebRootPath, "images");
FileImage = Guid.NewGuid().ToString() + "_" + model.AvataPast.FileName;
string filePath = Path.Combine(uploadsFolder, FileImage);
using (var fileStream = new FileStream(filePath, FileMode.Create))
{
model.AvataPast.CopyTo(fileStream);
}
edit.Avata = FileImage;
}
return(context.SaveChanges());
}
public ActionResult EditProduct(int productId)
{
ProductService productService = new ProductService();
EditProductViewModel editProductViewModel = new EditProductViewModel();
ProductModel productModel = new ProductModel();
productModel = productService.Get(productId);
editProductViewModel.Id = productModel.Id;
editProductViewModel.Title = productModel.Title;
editProductViewModel.Author = productModel.Author;
editProductViewModel.Price = productModel.Price;
editProductViewModel.Balance = productModel.Balance;
editProductViewModel.Detail = productModel.Detail;
editProductViewModel.Isbn = productModel.Isbn;
editProductViewModel.UpdateBy = productModel.UpdateBy;
editProductViewModel.UpdateTime = productModel.UpdateTime;
editProductViewModel.Image = productModel.Image;
editProductViewModel.CategoryId = productModel.CategoryId;
//var model = new AddProductViewModel();
CategoryService categoryService = new CategoryService();
List <CategotyModel> categorys = new List <CategotyModel>();
categorys = categoryService.GetCategory();
return(View(editProductViewModel));
}
public IActionResult EditProduct(EditProductViewModel editProduct)
{
Product product = new Product();
if (editProduct.ImageName == null)
{
if (editProduct.ExistingImageName != null)
{
product.ImageName = editProduct.ExistingImageName;
}
}
else
{
product.ImageName = editProduct.ImageName.FileName;
}
product.Id = editProduct.Id;
product.Name = editProduct.Name;
product.Description = editProduct.Description;
product.Price = editProduct.Price;
int result = _productRepository.EditProduct(product);
if (result > 0 && editProduct.ImageName != null)
{
string folderName = this.UploadImageToFolder(editProduct.ImageName);
var imgPath = Path.Combine(folderName, editProduct.ExistingImageName);
if (System.IO.File.Exists(imgPath))
{
System.IO.File.Delete(imgPath);
}
}
return RedirectToAction("Index", "Home");
}
public void Init()
{
_editProductViewModel = new EditProductViewModel(_eventAggregatorMock.Object);
}
