public async Task <IActionResult> UpdateProduct(UpdateProductViewModel UpdateProduct)
{
var type = await _dbContext.Category.FirstOrDefaultAsync(x =>
x.CategoryName == UpdateProduct.CateName);
var currProduct = await _dbContext.Product.FirstOrDefaultAsync(x =>
x.ProductId == UpdateProduct.ProductId);
if (ModelState.IsValid)
{
currProduct.CateId = type.CateID;
currProduct.ProductName = UpdateProduct.ProductName;
currProduct.Describe = UpdateProduct.Describe;
currProduct.Price = UpdateProduct.Price;
currProduct.DiscountPrice = UpdateProduct.DiscountPrice;
if (UpdateProduct.Image != null)
{
DeleteImage(currProduct.Image);
currProduct.Image = SetPhotoPath(UpdateProduct.Image);
}
_dbContext.Product.Update(currProduct);
var updated = await _dbContext.SaveChangesAsync();
}
return(RedirectToAction("ProductMgn", new { typeId = type.CateID, updated = currProduct.ProductId }));
}
public async Task <IActionResult> Update(UpdateProductViewModel model)
{
if (ModelState.IsValid)
{
Product product = await _repository.FindOne(model.Id);
if (product == null)
{
ModelState.AddModelError(string.Empty, "This product cannot be found in the database.");
return(View(model));
}
product = _productMapper.UpdateExistingProduct(model, product);
var result = await _repository.Update(product);
if (result == null)
{
ModelState.AddModelError(string.Empty, "Product update failed. Try again.");
return(View(model));
}
return(RedirectToAction(nameof(Details), new { productId = result.Id }));
}
return(View(model));
}
public ProductDetailsViewModel UpdateProduct(UpdateProductViewModel userModel)
{
var dalModel = new StoreDALModel();
dalModel.ProductID = userModel.ProductID;
dalModel.ProductName = userModel.ProductName;
dalModel.Quantity = userModel.Quantity;
dalModel.Price = userModel.Price;
_inventoryStore.UpdateProduct(dalModel);
var cartDAL = new CartDALModel();
cartDAL.ProductID = userModel.ProductID;
cartDAL.ProductName = userModel.ProductName;
cartDAL.Quantity = userModel.Quantity;
cartDAL.Price = userModel.Price;
_cartStore.UpdateOtherProperties(cartDAL);
var productDetails = new ProductDetailsViewModel();
productDetails.ProductID = dalModel.ProductID;
productDetails.ProductName = dalModel.ProductName;
productDetails.Quantity = dalModel.Quantity;
productDetails.Price = dalModel.Price;
return(productDetails);
}
public IActionResult Update(int id)
{
var product =
_productService
.GetProductFull(id);
if (product == null)
{
return(NotFound());
}
var model = new UpdateProductViewModel()
{
Name = product.Name,
Description = product.Description,
Price = product.Price
};
_PopulateBrands(model, product.Brand.Id.ToString());
_PopulateCategories(
model,
product
.Categories
.Select(x => x.Id.ToString())
);
_PopulateRatings(model, product.Id);
return(View(model));
}
public ProductDetailsViewModel ShowUpdatedProduct(int id, UpdateProductViewModel userModel)
{
var dalModel = new ProductsDALModel();
//dalModel.ProductID = userModel.ProductID;
dalModel.ProductID = userModel.ProductID;
dalModel.ProductName = userModel.ProductName;
//dalModel.SupplierID = userModel.SupplierID;
//dalModel.CategoryID = userModel.CategoryID;
dalModel.QuantityPerUnit = userModel.QuantityPerUnit;
dalModel.UnitPrice = userModel.UnitPrice;
dalModel.UnitsInStock = userModel.UnitsInStock;
dalModel.UnitsOnOrder = userModel.UnitsOnOrder;
dalModel.ReorderLevel = userModel.ReorderLevel;
dalModel.Discontinued = userModel.Discontinued;
_productStore.UpdateProduct(dalModel, id);
var productDetails = new ProductDetailsViewModel();
productDetails.ProductName = dalModel.ProductName;
productDetails.SupplierID = dalModel.SupplierID;
productDetails.CategoryID = dalModel.CategoryID;
productDetails.QuantityPerUnit = dalModel.QuantityPerUnit;
productDetails.UnitPrice = dalModel.UnitPrice;
productDetails.UnitsInStock = dalModel.UnitsInStock;
productDetails.UnitsOnOrder = dalModel.UnitsOnOrder;
productDetails.ReorderLevel = dalModel.ReorderLevel;
productDetails.Discontinued = dalModel.Discontinued;
return(productDetails);
}
public async Task <int> Update(long id, UpdateProductViewModel updateProductViewModel)
{
try
{
Product product = await _daxoneDBContext.Products.FindAsync(id);
if (product == null)
{
return(-1);
}
product.Name = updateProductViewModel.Name;
product.ImageUrl = updateProductViewModel.ImageUrl;
product.Description = updateProductViewModel.Description;
product.Price = updateProductViewModel.Price;
product.Quantity = updateProductViewModel.Quantity;
product.CategoryId = updateProductViewModel.CategoryId;
product.SupplierId = updateProductViewModel.SupplierId;
product.PromotionPrice = updateProductViewModel.PromotionPrice;
product.Warranty = updateProductViewModel.Warranty;
product.Frame = updateProductViewModel.Frame;
product.Rims = updateProductViewModel.Rims;
product.Tires = updateProductViewModel.Tires;
product.Weight = updateProductViewModel.Weight;
product.WeightLimit = updateProductViewModel.WeightLimit;
product.Status = updateProductViewModel.Status;
product.ShowOnHome = updateProductViewModel.ShowOnHome;
await _daxoneDBContext.SaveChangesAsync();
return(1);
}
catch (Exception)
{
return(-1);
}
}
public void Open(UpdateProductViewModel model, bool Method = false)
{
Result = "";
if (Method == true)
{
AddOrEdit = "Edit";
GetProduct = model;
Servicejoin = string.Join(",", model.Product.Services);
Categoryjoin = string.Join(",", model.Product.Category);
Tagjoin = string.Join(",", model.Product.Tags);
}
else
{
AddOrEdit = "Add";
GetProduct = new UpdateProductViewModel {
Product = new GetProductViewModel()
};
}
Style = "block;";
Show = "show";
ShowBackdrop = true;
StateHasChanged();
}
public async Task EditModel()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString())
.Options;
var dbContext = new ApplicationDbContext(options);
var repository = new EfDeletableEntityRepository <Product>(dbContext);
var service = new ProductService(repository);
var product = new Product
{
CategoryId = 1,
Name = "Tiramisu",
Description = "450g.",
Price = 5.5m,
ImageUrl = "https://www.google.com/url?sa=i&url=https%3A%2F%2Fwww.dailymail.co.uk%2Fhealth%2Farticle-7469271%2FA-beer-day-diabetes-bay-scientific-review-finds.html&psig=AOvVaw3hd5f03NOeMM5oVP1XNLsJ&ust=1587379220785000&source=images&cd=vfe&ved=0CAIQjRxqFwoTCIjHu8em9OgCFQAAAAAdAAAAABAI",
};
await repository.AddAsync(product);
await repository.SaveChangesAsync();
var newProduct = new UpdateProductViewModel
{
Description = product.Description,
Name = product.Name,
Price = 5.9m,
};
await service.EditModel(newProduct, product.Id, null);
Assert.Equal(5.9m, product.Price);
}
public async Task <IActionResult> Update(UpdateProductViewModel model)
{
var productDto = _productDtoFactory.UpdateProductDto(model.Id, model.Title, model.Description, model.Feature, model.Price, model.QuantityInStock, model.Weight);
await _productService.UpdateProductAsync(productDto);
return(View());
}
public void Gallery_Product_ApiEdit()
{
var urlapi = new UrlApi()
{
Url = "https://localhost:44397/api/v1/"
};
var client = new WebClient();
var option = new Mock <IOptions <UrlApi> >();
option.Setup(c => c.Value).Returns(urlapi);
var getapi = new GetProductApi(client, option.Object);
var result = client.DownloadString(option.Object.Value.Url + "product/1/1");
var getAllProduct = JsonConvert.DeserializeObject <GetAllProductViewModel>(result);
var product = getAllProduct.Products.LastOrDefault();
var find = new FindProductViewModel {
Customer = product.Customer, SiteName = product.SiteName, SiteUrl = product.SiteUrl
};
product.Customer = "Dorika";
var model = new UpdateProductViewModel {
ProductBefore = find, Product = product
};
result = getapi.Edit(model);
Assert.Equal("Modified", result);
}
public IActionResult Update(int id, UpdateProductViewModel updateProductVM)
{
if (!ModelState.IsValid)
{
return(View());
}
if (updateProductVM.Products.ProductImage != null && updateProductVM.Products.ProductImage.Length > 0)
{
var uploads = Path.Combine(_environment.WebRootPath, "uploads");
using (var fileStream = new FileStream(Path.Combine(uploads, updateProductVM.Products.ProductImage.FileName), FileMode.Create))
{
updateProductVM.Products.ProductImage.CopyTo(fileStream);
}
updateProductVM.Products.ProductImagePath = updateProductVM.Products.ProductImage.FileName.ToString();
}
_productRepository.Update(updateProductVM.Products);
try
{
_productRepository.Save();
}
catch (Exception ex)
{
return(View(ex));
}
return(RedirectToAction("Index"));
}
public IActionResult Delete(int id, UpdateProductViewModel productVM)
{
var originalProd = _productRepository.GetById(productVM.Products.ProductId);
_productRepository.Delete(productVM.Products.ProductId);
_categoryRepository.Save();
var uploads = Path.Combine(_environment.WebRootPath, "uploads");
try
{
FileInfo f = new FileInfo(uploads + "/" + originalProd.ProductImagePath);
f.Delete();
}
catch
{
// throw ex;
}
if (TempData != null)
{
if (TempData.ContainsKey("result"))
{
TempData["result"] = "Product Deleted";
}
else
{
TempData.Add("result", "Product Deleted");
}
}
return(RedirectToAction("Index"));
}
/// <summary>
/// GET: Product/Update/ID
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public ActionResult Update(int id)
{
UpdateProductViewModel updateProductViewModel = new UpdateProductViewModel();
updateProductViewModel.Product = businessManager.GetProductById(id);
return(View(updateProductViewModel));
}
public bool UpdateProduct(UpdateProductViewModel model)
{
var sql = $@"UPDATE Products
SET ProductName = @{nameof(model.Name)},
QuantityPerUnit = @{nameof(model.QuantityPerUnit)},
UnitPrice = @{nameof(model.UnitPrice)},
UnitsInStock = @{nameof(model.UnitsInStock)},
UnitsOnOrder = @{nameof(model.UnitsOnOrder)},
ReorderLevel = @{nameof(model.ReorderLevel)},
Discontinued = @{nameof(model.Discontinued)}
WHERE ProductID = @{nameof(model.Id)}";
using (var connection = new SqlConnection(_config.ConnectionString))
{
try
{
var result = connection.Execute(sql, model);
return(true);
}
catch
{
throw new Exception();
}
}
}
public async Task <IActionResult> Update(int id, UpdateProductViewModel model)
{
if (ModelState.IsValid)
{
var product =
new ProductBase()
{
Id = id,
Name = model.Name,
Description = model.Description,
Price = model.Price
};
var selectedCategoriesIds =
model
.SelectedCategories?
.Select(x => int.Parse(x)) ?? new int[0];
var selectedBrandId =
int.Parse(
model
.SelectedBrand
);
if (await TryUpdateModelAsync(product))
{
_productService
.UpdateProductBase(product, selectedBrandId, selectedCategoriesIds);
return(RedirectToAction("ListProducts", "Admin", null));
}
}
_PopulateBrands(model);
_PopulateCategories(model);
_PopulateRatings(model);
return(View(model));
}
public async Task <IActionResult> UpdateProduct(UpdateProductViewModel input)
{
string cartId = this.HttpContext.Session.Get <string>(base.AppSettings.ShoppingCartSessionKey);
ShoppingCartViewModel cartModel = null;
if (cartId == null)
{
if (cartId == null)
{
return(BadRequest("Shopping cart is not initialized!"));
}
}
else
{
try
{
cartModel = new ShoppingCartViewModel(await this.cartManager.UpdateProductAsync(cartId, input));
}
catch (EntityNotFoundException ex)
{
return(NotFound(ex.Message));
}
}
return(Json(cartModel));
}
public async Task <ResultViewModel> Update(
[FromRoute] string product_id,
[FromBody] UpdateProductViewModel productModel)
{
bool productIdIsValid = Guid.TryParse(product_id, out Guid output);
if (!productIdIsValid)
{
return new ResultViewModel()
{
Success = false,
Message = "ID inválido."
}
}
;
var product = await _productRepository.Find(product_id);
if (product == null)
{
return new ResultViewModel()
{
Success = false,
Message = "Produto não encontrado."
}
}
;
if (productModel.Name != null)
{
product.SetName(productModel.Name);
}
if (productModel.Price != 0)
{
product.SetPrice(productModel.Price);
}
if (product.Invalid)
{
return new ResultViewModel()
{
Success = false,
Message = "Dados inválidos.",
Data = product.Notifications
}
}
;
await _productRepository.Update(product);
return(new ResultViewModel()
{
Success = true,
Data = new ListProductViewModel(product)
});
}
}
}
public ProductListItemViewModel EditProduct(UpdateProductViewModel model)
{
_productStore.UpdateProduct(model);
var dalModel = _productStore.GetProductDALModelById(model.Id);
var newModel = new ProductListItemViewModel(dalModel);
return(newModel);
}
public async Task <IActionResult> Edit(Guid id, string returnUrl = "")
{
ViewBag.ReturnUrl = string.IsNullOrEmpty(returnUrl) ? "" : returnUrl;
var getService = await _productService.Get(id);
UpdateProductViewModel model = new UpdateProductViewModel()
{
Id = getService.Result.Id,
ProductName = getService.Result.ProductName,
CreatedById = getService.Result.CreatedById,
ModifiedById = User.FindFirst(ClaimTypes.NameIdentifier).Value,
ProductDetail = getService.Result.ProductDetail,
ProductFuelType = getService.Result.ProductFuelType,
ProductGearType = getService.Result.ProductGearType,
ProductImageUrl = getService.Result.ProductImageUrl,
ProductMinPrice = getService.Result.ProductMinPrice,
ProductPrice = getService.Result.ProductPrice,
ProductKm = getService.Result.ProductKm,
ProductYear = getService.Result.ProductYear,
ProductCityId = getService.Result.ProductCityId,
ProductBrandId = getService.Result.ProductBrandId,
StartOfferPrice = getService.Result.StartOfferPrice,
CategoryId = getService.Result.Brand.SubCategory.CategoryId,
CategoryName = getService.Result.Brand.SubCategory.Category.CategoryName,
SubCategoryId = getService.Result.Brand.SubCategoryId,
SubCategoryName = getService.Result.Brand.SubCategory.SubCategoryName,
BrandName = getService.Result.BrandName
};
//var brandList = await _brandService.GetAll();
//ViewBag.brandDDL = brandList.Result.Select(x => new SelectListItem
//{
// Selected = false,
// Text = x.BrandName,
// Value = x.Id.ToString()
//}).ToList();
var cityList = await _cityService.GetAll();
ViewBag.cityDDL = cityList.Result.Select(x => new SelectListItem
{
Selected = false,
Text = x.CityName,
Value = x.Id.ToString()
}).ToList();
var category = await _categoryService.GetAll();
ViewBag.Category = category.Result.Select(c => new SelectListItem
{
Selected = false,
Text = c.CategoryName,
Value = c.Id.ToString()
}).ToList();
return(View(model));
}
public ActionResult Update(UpdateProductViewModel model)
{
if (!ModelState.IsValid)
{
Helpers.InvalidModelState(ModelState);
}
_productsService.Update(model);
return(Json(true));
}
public async Task <IActionResult> Edit(int Id, [Bind("Name, Price, Description, Stock")] UpdateProductViewModel product)
{
product.Id = Id;
var updatedProduct = _mapper.Map <ProductModel>(product);
await _service.UpdateProduct(updatedProduct);
return(RedirectToAction("Index"));
}
public IActionResult Update(int id)
{
var prod = new UpdateProductViewModel
{
Products = _productRepository.GetById(id),
Categories = _categoryRepository.GetAll()
};
return(View(prod));
}
public UpdateProductViewModel GetUpdateProductView(int id)
{
var dalProduct = _productStore.GetProductDALModelById(id);
var updateProduct = new UpdateProductViewModel()
{
Id = dalProduct.ProductID
};
return(updateProduct);
}
public IActionResult UpdateProduct(UpdateProductViewModel productViewModel)
{
if (!ModelState.IsValid)
{
return(View(productViewModel));
}
_productService.Update(productViewModel.Product);
TempData["message"] = "Your product has been successfully updated.";
return(RedirectToAction("Index"));
}
public IActionResult UpdateProduct(int productId)
{
UpdateProductViewModel model = new UpdateProductViewModel
{
Product = _productService.GetProduct(productId),
Categories = _categoryService.GetAll()
};
return(View(model));
}
public UpdateProductViewModel GetUpdateProductViewModel(UpdateProductViewModel model = null)
{
if (model == null)
{
model = new UpdateProductViewModel();
}
model = GetNewProductViewModel(model) as UpdateProductViewModel;
return(model);
}
public UpdateProductPage(Product product)
{
InitializeComponent();
var updateProductViewModel = new UpdateProductViewModel(Navigation);
updateProductViewModel.Product = product;
BindingContext = updateProductViewModel;
NavigationPage.SetHasNavigationBar(this, false); // Hide nav bar
}
public IActionResult UpdateProduct(UpdateProductViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_productService.UpdateProduct(model);
return(Ok(model));
}
public void UpdateProduct(UpdateProductViewModel model)
{
var dbProduct = _repo.GetById(model.Id);
dbProduct.Name = model.Name;
dbProduct.Photo = model.Photo;
dbProduct.Price = model.Price;
dbProduct.UpdatedAt = DateTime.UtcNow;
_uow.Commit();
}
public async Task <IActionResult> Post([FromBody] UpdateProductViewModel Product)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
await productRepository.UpdateItem(mapper.Map <Product>(Product));
return(Ok(Product));
}
public ActionResult Update(FormCollection formCollection, [FetchProduct(KeyName = "productid")]ProductEntity model, UpdateProductViewModel vo)
{
if (ModelState.IsValid)
{
var id = model.Id;
model = Mapper.Map(vo, model);
//model.Brand = _brandRepository.Find(vo.Brand_Id);
//model.Store = _storeRepository.Find(vo.Store_Id);
//model.Tag = _tagRepository.Find(vo.Tag_Id);
model.UpdatedDate = DateTime.Now;
model.UpdatedUser = base.CurrentUser.CustomerId;
model.Id = id;
model.RecommendedReason = String.Empty;
model.Favorable = String.Empty;
_productRepository.Update(model);
return new RestfulResult
{
Data = new ExecuteResult<int>(model.Id) { StatusCode = StatusCode.Success, Message = "" }
};
}
else
{
// 如果我们进行到这一步时某个地方出错，则重新显示表单
//var dto = new CreateDto { Tags = tagList };
//dto.Vo = vo;
//dto.IsError = true;
//return View("Success",new SuccessViewModel{});
List<string> sb = new List<string>();
//获取所有错误的Key
List<string> Keys = ModelState.Keys.ToList();
//获取每一个key对应的ModelStateDictionary
foreach (var key in Keys)
{
var errors = ModelState[key].Errors.ToList();
//将错误描述添加到sb中
foreach (var error in errors)
{
sb.Add(error.ErrorMessage);
}
}
return new RestfulResult
{
Data = new ExecuteResult<List<string>>(sb) { StatusCode = StatusCode.ClientError, Message = "验证失败" }
};
}
}
