public async Task <HttpResponseMessage> EditProduct(ProductViewModel product)
{
ProductUpdate productOut = new ProductUpdate();
productOut.Title = product.Title;
productOut.Description = product.Description;
productOut.DescriptionFull = product.DescriptionFull;
productOut.IsActive = product.IsActive;
if (product.Image != null)
{
productOut.Images.Add(product.Image.ImageUrl);
}
productOut.CategoryId = product.Category;
productOut.Stock = product.Stock;
productOut.Price = product.Price;
using (HttpClient httpClient = new HttpClient())
{
string content = JsonConvert.SerializeObject(productOut).ToString();
var stringContent = new StringContent(content, Encoding.UTF8, "application/json");
httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", HttpContext.Current.Session["AccessToken"].ToString());
var response = await httpClient.PutAsync(uri + "Products/" + product.Id, stringContent);
return(response);
}
}
public ServiceResponse Update(ProductUpdate request)
{
var serviceResponse = new ServiceResponse();
if (request == null)
{
serviceResponse.Errors.Add("Request", "Should not be null");
}
var product = _unitOfWork.ProductRepository.GetById(request.Id);
if (product == null)
{
serviceResponse.Errors.Add(nameof(request.Id), $"Product with Id = {request.Id} doesnt exsits");
serviceResponse.StatusCode = 400;
}
var category = _unitOfWork.CategoryRepository.GetById(request.CategoryId);
if (category == null)
{
serviceResponse.Errors.Add(nameof(request.Id), $"Category with Id = {request.Id} doesnt exsits");
serviceResponse.StatusCode = 400;
}
if (serviceResponse.IsSuccess)
{
product = _mapper.Map <Product>(request);
_unitOfWork.ProductRepository.Update(product);
_unitOfWork.Save();
serviceResponse.StatusCode = 204;
}
return(serviceResponse);
}
public IActionResult UpdateProduct(int id, [FromBody] ProductUpdate product)
{
var productToUpdate = ProductsDataStore.Current.Products.FirstOrDefault(c => c.Id == id);
if (productToUpdate == null)
{
return(NotFound());
}
if (product.Name != null)
{
productToUpdate.Name = product.Name;
}
if (product.Price != null)
{
productToUpdate.Price = product.Price;
}
var productToReturn = ProductsDataStore.Current.Products.FirstOrDefault(c => c.Id == id);
if (productToReturn == null)
{
return(NotFound());
}
return(Ok(productToReturn));
}
public IActionResult Put(int id, [FromBody] ProductUpdate product)
{
product.Id = id;
var productResponse = _productService.Update(product);
return(productResponse.ToJsonResult());
}
public async Task <TMapTo> UpdateProductAsync <TMapTo>(ProductUpdate productToUpdate)
where TMapTo : ProductBL
{
try
{
var product = await this.GetProductByIdAsync(productToUpdate.ProductId);
var mappedDtoModel = _mapper.Map <ProductUpdate, ProductDTO>(productToUpdate, product);
var updatedModel = _productsContext.Products.Update(mappedDtoModel);
if (updatedModel is null)
{
throw new UpdateOperationException(
$"Can not update entity {typeof(ProductDTO)} using data from object parameter {nameof(productToUpdate)}");
}
await _productsContext.SaveChangesAsync();
return(_mapper.Map <TMapTo>(updatedModel));
}
catch (Exception ex)
{
throw new UpdateOperationException(
"Some error occured while updating product. Updated changes won't be applied", ex);
}
}
public async Task <ApiResult <UpdateReturn> > Update(int id, ProductUpdate bundle)
{
ApiResult <UpdateReturn> result;
if (bundle.Image != null)
{
var product = new UpdateReturn()
{
Id = bundle.Id,
Code = bundle.Code,
Description = bundle.Description,
Name = bundle.Name,
IdProductType = bundle.IdProductType
};
var json = JsonConvert.SerializeObject(product);
var httpContent = new StringContent(json, Encoding.UTF8, "application/json");
var url = $"/api/product/" + $"{id}";
result = await Update <UpdateReturn>(url, httpContent);
var image = await this.UpdateImage(id, bundle.Image);
result.ResultObj.Image = image.ResultObj;
}
else
{
var json = JsonConvert.SerializeObject(bundle);
var httpContent = new StringContent(json, Encoding.UTF8, "application/json");
var url = $"/api/product/" + $"{id}";
result = await Update <UpdateReturn>(url, httpContent);
}
return(result);
}
public void Put(string id, [FromBody] ProductUpdate productUpdate)
{
this.mediator.Send(
new EditProduct {
Price = productUpdate.Price, ProductId = Guid.Parse(id), Name = productUpdate.Name
});
}
public async Task <IHttpActionResult> UpdateProduct([FromUri] int id, [FromBody] ProductUpdate model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState)); // 400
}
var product = await _context.Products.FindAsync(id);
if (product == default)
{
return(NotFound()); // 404
}
if (!string.IsNullOrEmpty(model.ProductName))
{
product.ProductName = model.ProductName;
}
if (!string.IsNullOrEmpty(model.UPC))
{
product.UPC = model.UPC;
}
if (model.Price > 0)
{
product.Price = model.Price;
}
if (await _context.SaveChangesAsync() == 1)
{
return(Ok()); // 200
}
return(InternalServerError()); // 500
}
public async Task <IActionResult> Edit([FromQuery] int id, [Bind("ProductId,ProductName,SupplierId,CategoryId,QuantityPerUnit,UnitPrice,UnitsInStock,UnitsOnOrder,ReorderLevel,Discontinued")] ProductUpdate products)
{
if (id != products.ProductId)
{
_logger.LogError("Product's id from request and model are not the same");
}
if (ModelState.IsValid)
{
try
{
var product = await _productsService.UpdateProductAsync <ProductUpdate>(products);
return(RedirectToAction(nameof(Index)));
}
catch (Exception ex)
{
_logger.LogError(ex,
$"Some error occured while processing Edit for product with id {products.ProductId}");
}
}
var availableCategories = await _categoriesService.GetCategoriesAsync <Category>();
var availableSuppliers = await _suppliersService.GetSuppliersAsync <Supplier>();
ViewData["CategoryId"] = new SelectList(availableCategories, "CategoryId", "CategoryName", products.CategoryId);
ViewData["SupplierId"] = new SelectList(availableSuppliers, "SupplierId", "CompanyName", products.SupplierId);
return(View(products));
}
public async Task <IActionResult> postUpdateProductInfo([FromBody] ProductUpdate value)
{
if (BUS_Controls.Controls.updateProductInfo(value))
{
return(new JsonResult(new ApiResponse <object>("update product ok")));
}
return(new JsonResult(new ApiResponse <object>(200, "update product failed")));
}
/// <inheritdoc />
public void Update(Guid id, ProductUpdate model)
{
ProductDb product = GetSingle(id);
product.Description = model.Description;
_dbContext.SaveChanges();
}
/// <param name='operations'>
/// Reference to the ZtherApiIntegration.API.IProducts.
/// </param>
/// <param name='code'>
/// Required.
/// </param>
/// <param name='model'>
/// Required.
/// </param>
public static CoordinateList Update(this IProducts operations, string code, ProductUpdate model)
{
return(Task.Factory.StartNew((object s) =>
{
return ((IProducts)s).UpdateAsync(code, model);
}
, operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult());
}
public async Task <ProductResponse> SetProductsPPOM(ProductUpdate request, Dictionary <string, string> parms = null)
{
var endPoint = ProductUpdate.Endpoint;
request.SecretKey = API.PpomKey;
return(API.DeserializeJSon <ProductResponse>(await API.PostRestful(endPoint, request, parms).ConfigureAwait(false)));
}
public async Task <IHttpActionResult> UploadProductFiles(NewProductFileDTO[] newProductFiles)
{
string userName = User.Identity.Name;
User user = db.Users.Where(_user => _user.UserName == userName).SingleOrDefault();
if (user == null)
{
throw new HttpResponseException(HttpStatusCode.Unauthorized);
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
for (int i = 0; i < newProductFiles.Length; i++)
{
long productId = newProductFiles[i].ProductID;
string visibility = newProductFiles[i].Visibility;
Product product = db.Products.Find(productId);
if (product == null)
{
return(NotFound());
}
if ((product.CompanyID.HasValue && product.CompanyID != user.Company.ID) && (product.TeamMembers.Where(teamMember => teamMember.UserID == user.Id && teamMember.CanEditTheProduct == true).SingleOrDefault() == null))
{
throw new HttpResponseException(HttpStatusCode.Unauthorized);
}
ProductFile productFile = Mapper.Map <NewProductFileDTO, ProductFile>(newProductFiles[i]);
ProductUpdate productUpdate = new ProductUpdate();
productFile.Product = product;
productFile.Type = ProductFileType.Other;
productFile.UploadedAt = DateTime.Now;
if (!string.IsNullOrEmpty(visibility) && visibility.ToLower() == "private")
{
productFile.Privacy = ProductFilePrivacy.Private;
}
productFile = db.ProductFiles.Add(productFile);
productUpdate.UserID = user.Id;
productUpdate.User = user;
productUpdate.ProductID = product.ID;
productUpdate.Product = product;
productUpdate.ProductFileID = productFile.ID;
productUpdate.ProductFile = productFile;
productUpdate.DateTime = DateTime.Now;
productUpdate.UpdateType = UpdateType.ProductFileAdded;
db.ProductUpdates.Add(productUpdate);
}
await db.SaveChangesAsync();
return(Ok());
}
public void Update(ProductUpdate product)
{
var currentProduct = _unitOfWork.ProductRepo.GetById(product.Id);
if (currentProduct != null)
{
currentProduct = Mapper.Map <Product>(product);
}
}
public async Task <ActionResult> PutAsync(Guid id, [FromBody] ProductUpdate product)
{
var productServiceModel = this.mapper.Map <ProductServiceModel>(product);
if (await this.productService.UpdateAsync(productServiceModel))
{
return(this.Ok(new { success = true }));
}
return(this.BadRequest());
}
public async Task <dynamic> Update([FromBody] ProductUpdate item)
{
if (item == null)
{
return new { JsonString = "Error" }
}
;
var currentUser = JwtIdentity.UserInfo(Thread.CurrentPrincipal.Identity);
//item.SubmiterUserId = currentUser.Id;
var result = await _sqlData.Product.Update(item);
return(new { Result = JsonConvert.DeserializeObject(result) });
}
public async Task <IActionResult> Update(int id, ProductUpdate productUpdate)
{
var product = await _productsContext.Products.FindAsync(id);
if (product == null)
{
return(StatusCode(500));
}
_mapper.Map(productUpdate, product);
await _productsContext.SaveChangesAsync();
return(Ok(_mapper.Map <ProductDto>(product)));
}
public ActionResult Edit(int id)
{
var service = CreateProductService();
var detail = service.GetProductByID(id);
var model =
new ProductUpdate
{
ProductID = detail.ProductID,
ProductName = detail.ProductName,
Price = detail.Price
};
return View(model);
}
private IActionResult ActualizarProductoParcialmente(Topicos.NorthWnd.Model.Models.Product elResultadoRecibido, JsonPatchDocument <ProductUpdate> parchesAlProducto)
{
var elProductoParaParchar = new ProductUpdate()
{
ProductId = elResultadoRecibido.ProductId,
ProductName = elResultadoRecibido.ProductName,
UnitPrice = elResultadoRecibido.UnitPrice,
Discontinued = elResultadoRecibido.Discontinued
};
parchesAlProducto.ApplyTo(elProductoParaParchar);
throw new NotImplementedException();
}
public bool UpdateProduct(ProductUpdate model)
{
using (var ctx = new ApplicationDbContext())
{
var entity =
ctx
.Products
.Single(e => e.ProductID == model.ProductID && e.OwnerID == _userID);
entity.ProductName = model.ProductName;
entity.Price = model.Price;
entity.ModifiedUtc = DateTimeOffset.UtcNow;
return(ctx.SaveChanges() == 1);
}
}
public IHttpActionResult Put(ProductUpdate product)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var service = CreateProductService();
if (!service.UpdateProduct(product))
{
return(InternalServerError());
}
return(Ok());
}
protected virtual async Task UpdateAsync(Guid skuId)
{
var entity = await _productUpdateRepository.FindAsync(x => x.ProductSkuId == skuId);
if (entity == null)
{
entity = new ProductUpdate(_guidGenerator.Create(), skuId);
await _productUpdateRepository.InsertAsync(entity);
}
else
{
await _productUpdateRepository.UpdateAsync(entity);
}
}
public void ReturnsNotFoundExceptionWhenupdatingNotExistingId()
{
//Arrange
var productsController = new ProductsController(GetProductsFacade());
var guid = new Guid("8b417428-cd89-4ff1-9248-6c2a89e1a3c6");
var productUpdate = new ProductUpdate()
{
Description = "New desc."
};
//Act
Func <ActionResult <Product> > action = () => productsController.UpdateDescription(guid, productUpdate);
//Assert
action.Should().Throw <NotFoundException>().WithMessage("Product has not been found.");
}
public async Task <IHttpActionResult> SetProductFileCategory(long id, ProductFileCategory category)
{
string userName = User.Identity.Name;
User user = db.Users.Where(_user => _user.UserName == userName).SingleOrDefault();
if (user == null)
{
throw new HttpResponseException(HttpStatusCode.Unauthorized);
}
ProductFile productFile = db.ProductFiles.Where(_productFile => _productFile.ID == id)
.Include(_productFile => _productFile.Product)
.Include(_productFile => _productFile.Product.TeamMembers)
.SingleOrDefault();
if (productFile == null)
{
return(NotFound());
}
if ((productFile.Product.CompanyID != user.Company.ID) && (productFile.Product.TeamMembers.Where(teamMember => teamMember.UserID == user.Id && teamMember.CanEditTheProduct == true).SingleOrDefault() == null))
{
throw new HttpResponseException(HttpStatusCode.Unauthorized);
}
if (productFile.Category == category)
{
return(Ok());
}
ProductUpdate productUpdate = new ProductUpdate();
productFile.Category = category;
db.Entry(productFile).State = EntityState.Modified;
productUpdate.UserID = user.Id;
productUpdate.User = user;
productUpdate.ProductID = productFile.ProductID;
productUpdate.Product = productFile.Product;
productUpdate.ProductFileID = productFile.ID;
productUpdate.ProductFile = productFile;
productUpdate.DateTime = DateTime.Now;
productUpdate.UpdateType = UpdateType.ProductFileEdited;
db.ProductUpdates.Add(productUpdate);
await db.SaveChangesAsync();
return(Ok());
}
public bool UpdateProduct(ProductUpdate model)
{
using (var ctx = new ApplicationDbContext())
{
var entity =
ctx
.Products
.Single(e => e.ProductId == model.ProducId && e.OwnerId == _userId);
entity.Title = model.Title;
entity.Description = model.Description;
entity.Price = model.Price;
entity.DateUpdated = DateTimeOffset.Now;
return(ctx.SaveChanges() == 1);
}
}
public async Task EditWithModel_ReturnsCurrentView_WhenModelIsNotValid()
{
_mockCatService.Setup(cs => cs.GetCategoriesAsync <Category>(It.IsAny <int?>()))
.ReturnsAsync(this.GetTestCategories());
_mockSupService.Setup(ss => ss.GetSuppliersAsync <Supplier>(It.IsAny <int?>()))
.ReturnsAsync(this.GetTestSuppliers());
_productsController.ModelState.AddModelError("name", "Product name is required");
var viewModel = new ProductUpdate();
var actual = await _productsController.Edit(It.IsAny <int>(), viewModel);
var result = Assert.IsType <ViewResult>(actual);
var model = Assert.IsAssignableFrom <ProductUpdate>(result.ViewData.Model);
}
public static async Task UpdateProduct(ProductUpdate updatedProduct, ProductItem productItem, DatabaseContext _context)
{
if (updatedProduct.SellPrice != -1)
{
productItem.SellPrice = updatedProduct.SellPrice;
}
if (updatedProduct.Discount != -1)
{
productItem.Discount = updatedProduct.Discount;
}
productItem.Returnable = updatedProduct.Returnable;
_context.Entry(productItem).State = EntityState.Modified;
await _context.SaveChangesAsync();
}
/// <summary>
/// 修改产品信息
/// </summary>
/// <returns></returns>
public int UpdateProduct(ProductUpdate Upd)
{
using (IDbConnection conn = new SqlConnection(connStr))
{
string sql = @"EXEC dbo.p_UpdateProduct @productId,
@productName,
@userId,
@productDetail,
@tradeId,
@typeId,
@addressId,
@stageId,
@updatorId " ;
var res = conn.Execute(sql, new { productId = Upd.ProductId, productName = Upd.ProductName, userId = Upd.UserId, productDetail = Upd.ProductDetail, tradeId = Upd.TradeId, typeId = Upd.TypeId, addressId = Upd.AddressId, stageId = Upd.StageId, updatorId = Upd.UpdatorId });
return(res);
}
}
public async Task <IActionResult> Update(int id, [FromBody] ProductUpdate request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var result = await _productService.Update(id, request);
if (!result.IsSuccessed)
{
return(BadRequest(result));
}
var list = await _productService.GetByUpdateProduct(id);
return(Ok(list));
}
private void WriteToCSV(RegistryQuery.AppNameVer anv, String server, String appVendor, ProductUpdate pu)
{
String servicePack = (String)htBuild[anv.DisplayVersion];
switch (pu) {
case ProductUpdate.DDC:
sw.WriteLine("{0},{1},{2},{3},{4}", appVendor, anv.DisplayName, anv.DisplayVersion, ddcPatches, server);
sw.Flush();
break;
case ProductUpdate.PSE:
sw.WriteLine("{0},{1},{2},{3},{4}", appVendor, anv.DisplayName, anv.DisplayVersion, psePatches, server);
sw.Flush();
break;
case ProductUpdate.NONE:
sw.WriteLine("{0},{1},{2},{3},{4}", appVendor, anv.DisplayName, anv.DisplayVersion, servicePack ,server);
sw.Flush();
break;
}
}
public virtual ActionResult Update(int id, ProductUpdate data)
{
if (ModelState.IsValid)
{
_ProductService.UpdateProduct(id, data);
return new EntityResult(MVC.Admin.Products.Index(), "Product saved.");
}
else {
return new Http400Result(ModelState);
}
//if (ModelState.IsValid) {
// var p = db.Products
// .Where(x => x.Id == product.Id)
// .Single();
// p.CategoryId = product.CategoryId;
// p.ShippingCategoryId = product.ShippingCategoryId;
// p.Description = product.Description;
// p.IsPublished = product.IsPublished;
// p.Name = product.Name;
// p.Price = product.Price;
// p.Available = product.Available;
// var guids = _stringToGuids(pictureIds);
// _SetProductPictures(p, guids);
// _SetProductTags(p, tagIds);
// db.Entry(p).State = EntityState.Modified;
// db.SaveChanges();
// return RedirectToAction("Index");
//}
//_PopulateCategoriesDropDownList(product.CategoryId);
//_PopulateShippingCategoriesDropDownList(product.ShippingCategoryId);
return View();
}
private IProductUpdate CheckForProductUpdate(Uri updateSource, int timeout)
{
var productUpdate = new ProductUpdate();
try
{
var webRequest = WebRequest.Create(updateSource);
// Skip proxy checking because it's slow.
webRequest.Proxy = null;
webRequest.Timeout = timeout * 1000;
using (var webResponse = webRequest.GetResponse())
using (var responseStream = webResponse.GetResponseStream())
{
var xmlDoc = new XmlDocument();
xmlDoc.Load(responseStream);
var productElement = xmlDoc.DocumentElement;
var minimalVersion = productElement.Attributes.GetAttributeByKeyOrNull<Version>("minimal-version");
var latestVersion = productElement.Attributes.GetAttributeByKeyOrNull<Version>("latest-version");
var url = productElement.Attributes.GetAttributeByKeyOrNull<Uri>("url");
var command = productElement.Attributes.GetAttributeByKeyOrNull<string>("command");
// Validate the xml file.
if (latestVersion == null || url == null)
throw new XmlException("Invallid update schema");
productUpdate.MinimalVersion = minimalVersion;
productUpdate.Url = url;
productUpdate.Command = command;
productUpdate.NewVersion = latestVersion;
}
}
catch (Exception ex)
{
_log.Error("Failed to retrieve update", ex);
}
return productUpdate;
}
