private async Task <TResponse <bool> > CanUpdate(UpdateProductModel request) { try { var product = await ReadOnlyRepository.QueryFirstOrDefaultAsync <ProductModel>(SqlQuery.PRODUCT_FIND_BY_NAME_AND_ID, new { request.Name, request.Id }); if (product.IsSuccess) { if (product.Data != null) { return(await Fail <bool>(ErrorEnum.PRODUCT_HAS_EXIST.GetStringValue())); } return(await Ok(true)); } return(await Fail <bool>(product.Message)); } catch (Exception exception) { return(await Fail <bool>(exception)); } }
public async Task <ActionResult <int> > UpdateProduct([FromBody] UpdateProductModel value) { return(Ok(await _mediator.Send(new UpdateProductRequest() { Model = value }))); }
public IActionResult UpdateProduct([FromBody] UpdateProductModel model) { try { var getProductResponse = _productRepository.GetById(model.ProductId); if (!getProductResponse.isStatusCodeSuccess() || getProductResponse.Data == null) { return(NotFound()); } var updateResponse = _productRepository.Update(model.ToEntity(getProductResponse.Data)); if (updateResponse.isStatusCodeSuccess() && updateResponse.Data != null) { return(StatusCode(updateResponse.StatusCode, ProductModel.ToModel(updateResponse.Data))); } else { return(StatusCode(updateResponse.StatusCode)); } } catch (Exception e) { return(InternalServerError()); } }
public async Task <Guid> UpdateProduct(UpdateProductModel product) { _logger.LogInformation(Resources.UpdatingProductLogMessage, product.ProductId); Guid updateProduct = await _dal.UpdateProduct(product); return(updateProduct); }
internal async Task <Guid> UpdateProduct(UpdateProductModel product) { var tIdParam = GetParameter(Resources.ProductIdParameterName, product.ProductId); var productReader = GetDataReader(Resources.GetProductByIdProc, new List <DbParameter> { tIdParam }); if (!productReader.HasRows) { await productReader.CloseAsync(); throw new Exception(string.Format(Resources.ProductDoesNotExistsErrorMessage, product.ProductId)); } await productReader.CloseAsync(); var idParam = GetParameter(Resources.IdParameter, product.ProductId); var descriptionParameter = GetParameter(Resources.ProductDescriptionParameterName, product.Description); var priceParameter = GetParameter(Resources.ProductPriceParameterName, product.Price); var reader = GetDataReader(Resources.UpdateProductProc, new List <DbParameter> { idParam, descriptionParameter, priceParameter }); if (reader.HasRows) { await reader.ReadAsync(); } var resultantId = reader.GetGuid(0); await reader.CloseAsync(); return(resultantId); }
public UpdateProductResultModel Update(long id, UpdateProductModel model) { BaseClient client = new BaseClient(); string url = "products/Update/" + id; return(client.Post <UpdateProductResultModel, UpdateProductModel>(url, model)); }
public async Task <ActionResult <ProductModel> > UpdateAsync( Guid id, [FromBody] UpdateProductModel model, CancellationToken cancellationToken ) { return(Ok(await mediator.Send(new UpdateProduct(id, model), cancellationToken))); }
public async Task <TResponse <bool> > Update(int userId, UpdateProductModel request, int permissionId) { try { var checkValid = await _userService.CheckPermission(userId, permissionId); if (checkValid.IsSuccess) { var canUpdate = await CanUpdate(request); if (canUpdate.IsSuccess) { var result = await WriteRepository.ExecuteAsync(SqlQuery.PRODUCT_UPDATE, new { request.Id, request.Name, request.ImportPrice, request.SellPrice, request.MinCount, request.MaxCount, request.WarrantyMonth, request.ProductUnitId, request.ProductGroupId, request.ProductStatusId, request.ManufacturerId, request.CountryId, request.Description, UserUpdated = userId, DateUpdated = DateTime.Now }); if (result.IsSuccess) { if (result.Data > 0) { return(await Ok(true)); } return(await Fail <bool>(ErrorEnum.BAD_REQUEST.GetStringValue())); } return(await Fail <bool>(result.Message)); } return(await Fail <bool>(canUpdate.Message)); } return(await Fail <bool>(checkValid.Message)); } catch (Exception exception) { return(await Fail <bool>(exception)); } }
public async Task <UpdateProductModel> Update(string id, UpdateProductModel p) { var product = await GetById(id); _mapper.Map(p, product); await _products.ReplaceOneAsync(p => p.Id == id, product); return(p); }
public async Task UpdateAsync(UpdateProductModel product) { var existingProduct = await _db.Products.SingleOrDefaultAsync(x => x.Id == product.Id); existingProduct.Name = product.Name; existingProduct.Price = product.Price; await _db.SaveChangesAsync(); }
public ProductModel Update(UpdateProductModel product) { var apiClient = new RestClient("http://localhost:2534/api"); var apiRequest = new RestRequest($"products/{product.Id}", Method.PUT, DataFormat.Json); apiRequest.AddJsonBody(product); var apiResponse = apiClient.Execute <ProductModel>(apiRequest); return(apiResponse.Data); }
public IActionResult Edit(UpdateProductModel product) { if (!ModelState.IsValid) { return(View(product)); } _productService.Update(product); return(RedirectToAction("Index")); }
public async Task <ActionResult <ProductDto> > UpdateProduct([FromForm] UpdateProductModel productModel) { var result = await _mediator.Send(new UpdateProductCommand { ProductDto = _mapper.Map <ProductDto>(productModel), Photo = productModel.Photo != null ? new FileAdapter(productModel.Photo) : null }); return(Ok(result)); }
public void UpdateProduct(UpdateProductModel model) { if (ModelState.IsValid) { // } else { BadRequest(); } }
public ActionResult UpdateProduct([FromBody] UpdateProductModel model) { var result = _productService.UpdateProduct( new Product { ProductName = model.ProductName, ProductDescription = model.ProductDescription, Amount = model.Amount }); return(Ok(result)); }
public IActionResult Edit(string id) { var product = _productService.Get(id); var model = new UpdateProductModel() { Id = product.Id, Category = product.Category, Name = product.Name }; return(View(model)); }
public IHttpActionResult UpdateProduct(int productId, UpdateProductModel model) { if (model == null) { return(NotFound()); } if (model.ProductId != productId) { return(NotFound()); } return(Ok()); }
//[ValidateInput(false)] public ActionResult UpdateProduct(UpdateProductModel Model) { try { _UserName = System.Web.HttpContext.Current.User.Identity.Name + " - DataEntryApp"; SearchHelper.DecodeModel(Model); _db.UpdateProduct(Model.ProductID, Model.ItemNumber, Model.ShortDescription ?? "", Model.Categories.Where(c => c != null).DefaultIfEmpty().Last(), Model.InfoTemplate, Model.AvailableInKitSetAsst, Model.MetaDescription ?? "", Model.AdditionalSpecs, Model.PleaseNote, Model.MetaKeyword ?? "", Model.KitSetincludes, Model.NewItemMeetingDate, Model.PrintGridDesc, Model.ProdCatSection, Model.ProdPageNmbr, Model.ProductnamePrint, Model.ProductPrintDesc, (!Model.ItemNumber.ToUpper().Contains("GP") ? Model.StyleClass : null), //don't add variant parents to GP items _UserName); _db.UpdateProductAttributes(Model.ProductID, string.Join(",", Model.Attributes?.Where(c => c != null))); _db.UpdateProductChemicals(Model.ProductID, string.Join(",", Model.Chemicals?.Where(c => c != null))); // don't add variants to GP items if (!Model.ItemNumber.ToUpper().Contains("GP")) { _db.UpdateStyleTraitValueProducts(Model.ProductID, (Model.StyleTraitValues != null ? string.Join(",", Model.StyleTraitValues?.Where(c => c != null)) : "")); } return(Json(new { Status = "Successful" })); } catch (Exception ex) { LoggingHelper.LogError(ex); return(Json(new { Status = "Error", Message = ex.Message })); } }
public ActionResult Update(HttpPostedFileBase fileBase, UpdateProductModel updateProduct) { var find = new ProductDAO().FindProduct(updateProduct.Id); string images; if (fileBase.ContentLength > 0) { string fileName = Path.GetFileNameWithoutExtension(fileBase.FileName); fileName += "_" + updateProduct.Id; fileName += Path.GetExtension(fileBase.FileName); string folderPath = Server.MapPath("~") + @"Images\product"; if (!Directory.Exists(folderPath)) { Directory.CreateDirectory(folderPath); } string path = Path.Combine(folderPath, fileName); fileBase.SaveAs(path); images = fileName; } else { images = find.images; } var product = new Product() { prId = updateProduct.Id, prName = updateProduct.Name, images = images, cateId = updateProduct.Category, prodId = find.prodId, description = updateProduct.Description, price = updateProduct.Price, amount = updateProduct.Amounts }; var dao = new ProductDAO().UpdateProduct(product); if (dao != null) { ViewBag.ProductId = dao; ViewBag.Category = new CategoryDAO().FindCategory(dao.cateId); ViewBag.Producer = new ProducerDAO().FindProducer(dao.prodId); ViewBag.CaletedPr = new ProductDAO().ProductCategoryDifferent(dao.prId); ViewBag.CategoryList = new CategoryDAO().ListAll(); return(RedirectToAction("Update", new { id = dao.prId })); } return(RedirectToAction("NotFound", "Error")); }
public async Task <IActionResult> UpdateProduct(UpdateProductModel model) { var productRequest = model.MapToFullRequest(); HttpResponseMessage response = await PutAsync("products", productRequest); if (!response.IsSuccessStatusCode) { TempData["ProductErrorMessage"] = await response.Content.ReadAsStringAsync(); } return(RedirectToAction(nameof(Index))); }
public Products UpdateProduct(int id, UpdateProductModel updateProductModel) { var product = _context.Products.FirstOrDefault(x => x.ProductId == id); if (product != null) { product.ProductName = updateProductModel.Name; product.UnitPrice = updateProductModel.UnitPrice; _context.SaveChanges(); } return(product); }
public ActionResult UpdataProductDescription(int id, UpdateProductModel model) { if (!model.IsValid()) { return(BadRequest(ErrorModel.GetErrorModel(model.GetValidationResults()))); } if (_productService.ProductByKey(id) is ProductDataModel p) { p.Description = model.Description; _productService.UpdateProduct(p); return(Ok()); } return(NotFound(ErrorModel.GetErrorModel("Not found.", "Id", "Id does not exist.", HttpStatusCode.NotFound))); }
public async Task <UpdateProductModel> Update(string id, UpdateProductModel p, IFormFile picture) { var product = await GetById(id); _mapper.Map(p, product); if (picture != null) { var imgId = UploadedFile(1, picture); product.ThumbnailId = imgId; } await _products.ReplaceOneAsync(p => p.Id == id, product); return(p); }
public IActionResult Edit(IFormCollection valueCollection) { string code = valueCollection["i_code"]; string name = valueCollection["i_name"]; string description = valueCollection["i_description"]; string priceStr = valueCollection["i_price"]; string idStr = valueCollection["i_id"]; string stock = valueCollection["i_stock"]; string versionStr = valueCollection["i_version"]; Decimal price = 0; Decimal.TryParse(priceStr, out price); long id = 0; long.TryParse(idStr, out id); Guid version = Guid.Empty; Guid.TryParse(versionStr, out version); ProductManagement pm = new ProductManagement(); UpdateProductModel model = new UpdateProductModel() { Code = code, Name = name, Description = description, Price = price, Version = version }; try{ UpdateProductResultModel result = pm.Update(id, model); } catch (Exception ex) { return(new ContentResult() { Content = "An error has occurred: " + Environment.NewLine + ex.Message }); } // pm.Update(id,model); //FIX ME return(RedirectToAction("Search", null)); }
public async Task <IActionResult> Post([FromBody] UpdateProductModel model) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var product = _mapper.Map <Product>(model); product = await _productyService.Create(product); var view = _mapper.Map <ProductModel>(product); return(Ok(view)); }
public async Task Attribute_Routing_Values_In_Url_Should_Bind_Parameter_FromBody() { var config = new HttpConfiguration(); config.MapHttpAttributeRoutes(); using (var server = new HttpTestServer(config)) { var client = server.CreateClient(); string url = "http://localhost/api/Products/5"; var data = new UpdateProductModel { Name = "New Name" // NB: No ProductId in data }; using (var response = await client.PostAsJsonAsync(url, data)) { Assert.AreEqual(HttpStatusCode.OK, response.StatusCode); } } }
public async Task <IActionResult> UpdateProduct(int productId, UpdateProductModel updateProductModel, Guid?cartToken) { var cart = GetOrCreateCart(cartToken); var product = await GetProduct(productId); if (product == null) { return(NotFound("Product not found")); } cart.UpdateProduct(product, updateProductModel.Quantity); _cartContext.SaveChanges(); return(Ok(MapToApiModel(cart))); }
public async Task <IActionResult> Update([FromBody] UpdateProductModel updateProductModel) { try { if (String.IsNullOrWhiteSpace(updateProductModel.Name) || String.IsNullOrWhiteSpace(updateProductModel.Description) || String.IsNullOrWhiteSpace(updateProductModel.StoreId) || String.IsNullOrWhiteSpace(updateProductModel.QuantityUnit)) { return(BadRequest("At least one of required fields are empty!")); } if (updateProductModel.Price <= 0) { return(BadRequest("Price must be greater than 0!")); } if (updateProductModel.Quantity < 0) { return(BadRequest("Quantity cannot be less than 0!")); } var product = Uow.ProductRepository.Get(updateProductModel.Id); if (product == null) { return(NotFound("Product with given Id was not found!")); } var store = Uow.StoreRepository.Get(updateProductModel.StoreId); if (store == null) { return(NotFound("Store with given Id was not found!")); } var entity = Mapper.Map(updateProductModel, product); var updatedProduct = Uow.ProductRepository.Update(entity); await Uow.CompleteAsync(); return(Ok(Mapper.Map <ProductModel>(Mapper.Map <ProductModel>(updatedProduct)))); } catch (Exception e) { Console.WriteLine(e); return(InternalServerError()); } }
public async Task <IActionResult> Update(string productId, UpdateProductModel product) { var apiRep = new APIResponse(); if (!(await _productService.IsExisting(productId))) { apiRep.Data = null; apiRep.Error = false; return(Ok(apiRep)); } var p = await _productService.Update(productId, product); apiRep.Data = p; apiRep.Error = false; return(Ok(apiRep)); }
public IActionResult AddProduct([FromBody] UpdateProductModel product) { if (product == null) { return(BadRequest()); } var productDto = new ProductDto() { Category = product.Category, Collection = product.Collection, Description = product.Description, LusId = product.LusId, Name = product.Name, Provider = product.Provider, Type = product.Type }; //_productService.AddProduct(productDto); return(Ok()); }