public async Task <IActionResult> Update([FromRoute] int id, [FromBody] UpdateBrandRequest request)
{
var brand = await _brandService.GetBrandByIdAsync(id);
if (brand == null)
{
return(NotFound());
}
brand.Name = request.Name;
var updated = await _brandService.UpdateBrandAsync(brand);
if (updated)
{
return(Ok(_mapper.Map <BrandResponse>(brand)));
}
return(BadRequest(new ErrorResponse {
Errors = new List <ErrorModel> {
new ErrorModel {
Message = "Failed to Created"
}
}
}));
}
public async Task <ActionResult> Edit(Guid id, EditBrandViewModel request)
{
if (!ModelState.IsValid)
{
Alert("Invalid Request", NotificationType.error, Int32.Parse(_appConfig.Value.NotificationDisplayTime));
return(View());
}
if (!id.Equals(request.Id))
{
Alert("Invalid Request", NotificationType.error, Int32.Parse(_appConfig.Value.NotificationDisplayTime));
return(View());
}
try
{
var brandUpdateRequest = new UpdateBrandRequest {
Id = request.Id, Name = request.Name, Description = request.Description
};
var result = await _brandService.Update(id, brandUpdateRequest);
if (!result.Success)
{
Alert($"Error: {result.Message}", NotificationType.error, Int32.Parse(_appConfig.Value.NotificationDisplayTime));
return(View());
}
Alert($"Brand Updated Successfully", NotificationType.success, Int32.Parse(_appConfig.Value.NotificationDisplayTime));
return(RedirectToAction(nameof(Index)));
}
catch
{
Alert($"Error Occurred While processing the request", NotificationType.error, Int32.Parse(_appConfig.Value.NotificationDisplayTime));
return(View());
}
}
public IHttpActionResult Update(UpdateBrandRequest requestModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
var brand = _brandService.GetById(requestModel.ID);
if (brand != null)
{
brand.UpdateBrand(requestModel);
var result = _brandService.Update(brand);
if (result != null)
{
var productCategoryVm = Mapper.Map <BrandDetailResponse>(result);
return(Ok(productCategoryVm));
}
}
}
catch (Exception ex)
{
Log.Website(ex);
}
return(BadRequest());
}
public static Brand ConvertToBrand(this UpdateBrandRequest updateRequest)
{
Brand brand = new Brand();
brand.BrandId = updateRequest.BrandId;
brand.Name = updateRequest.Name;
return(brand);
}
public async Task <IActionResult> UpdateBrandAsync([FromRoute] Guid id, [FromBody] UpdateBrandRequest brand)
{
var obj = await _brandService.GetBrandByIdAsync(id);
if (obj == null)
{
return(NotFound());
}
return(Accepted(await _brandService.UpdateBrandAsync(id, brand)));
}
public static void UpdateBrand(this Brand model, UpdateBrandRequest updateModel)
{
model.Name = updateModel.Name;
model.Alias = updateModel.Alias;
model.Description = updateModel.Description;
model.Logo = updateModel.Logo;
model.MetaDescription = updateModel.MetaDescription;
model.MetaKeyword = updateModel.MetaKeyword;
model.UpdateDate = updateModel.UpdateDate;
model.UpdateBy = updateModel.UpdateBy;
model.Status = updateModel.Status;
}
public UpdateBrandResponse EditBrand(UpdateBrandRequest updateBrandRequest)
{
UpdateBrandResponse updateBrandResponse = null;
if (updateBrandRequest.Id == updateBrandRequest.Brand.Id)
{
var brand = _messageMapper.MapToBrand(updateBrandRequest.Brand);
_brandRepository.UpdateBrand(brand);
var brandDto = _messageMapper.MapToBrandDto(brand);
updateBrandResponse = new UpdateBrandResponse
{
};
}
return(updateBrandResponse);
}
public UpdateBrandRespones EditeBrand(UpdateBrandRequest updatebrandRequest)
{
UpdateBrandRespones updateBrandRespones = null;
if (updatebrandRequest.Id == updatebrandRequest.Brand.IdDto)
{
var brand = _messageMapper.MapToBrand(updatebrandRequest.Brand);
_brandRepository.EditBrand(brand);
var brandDto = _messageMapper.MapToBrandDto(brand);
return(new UpdateBrandRespones
{
});
}
return(updateBrandRespones);
}
public UpdateBrandResponse EditBrand(UpdateBrandRequest request)
{
var response = new UpdateBrandResponse();
WithErrorHandling(() =>
{
var brand = request.Brand.MapToBrand();
_brandRepository.UpdateBrand(brand);
response.Messages.Add("Successfully updated the brand");
response.StatusCode = HttpStatusCode.OK;
}, response);
return(response);
}
public UpdateBrandResponse UpdateBrand(UpdateBrandRequest request)
{
UpdateBrandResponse response = new UpdateBrandResponse();
try
{
Brand brand = request.ConvertToBrand();
brandRepository.Update(brand);
response.Success = true;
}
catch (Exception ex)
{
response.Success = false;
response.Message = ex.Message;
}
return(response);
}
public IActionResult Update(long id, UpdateBrandRequest request)
{
try
{
var existing = _serviceUow.BrandService.Exists(id);
if (!existing)
{
return(NotFound("Brand could not be found"));
}
var brand = Mapper.Map <Brand>(request.Brand);
return(Ok(Mapper.Map <BrandDTO>(_serviceUow.BrandService.UpdateBrand(brand))));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public ActionResult Edit(BrandSinglePageViewModel model)
{
if (model.BrandViewModel.BrandId == 0)
{
CreateBrandRequest request = new CreateBrandRequest();
CreateBrandResponse response = new CreateBrandResponse();
request.Name = model.BrandViewModel.Name;
response = brandService.CreateBrand(request);
if (response.Success)
{
return(RedirectToAction("Index"));
}
else
{
model.Success = false;
model.ErrorMessage = response.Message;
return(View(model));
}
}
else
{
UpdateBrandRequest request = new UpdateBrandRequest();
UpdateBrandResponse response = new UpdateBrandResponse();
request.BrandId = model.BrandViewModel.BrandId;
request.Name = model.BrandViewModel.Name;
response = brandService.UpdateBrand(request);
if (response.Success)
{
return(RedirectToAction("Index"));
}
else
{
model.Success = false;
model.ErrorMessage = response.Message;
return(View(model));
}
}
}
public async Task <UpdateBrandResponse> UpdateBrandAsync(Guid id, UpdateBrandRequest brand)
{
try
{
var obj = new Brand()
{
Id = id,
Name = brand.Name
};
await _brandRepository.UpdateBrandAsync(obj);
var response = await _brandRepository.GetBrandByIdAsync(obj.Id);
var result = _mapper.Map <UpdateBrandResponse>(response);
return(result);
}
catch (ArgumentNullException ex)
{
throw new ArgumentNullException("An error has occurred");
}
}
public async Task <ServiceResponse <Brand> > Update(Guid id, UpdateBrandRequest request)
{
try
{
var result = await _baseRepository.GetById(id);
if (result == null)
{
return(new ServiceResponse <Brand>($"The requested Brand could not be found"));
}
result.Name = request.Name;
result.Description = request.Description;
result.LastUpdated = DateTime.Now;
await _baseRepository.Update(id, result);
return(new ServiceResponse <Brand>(result));
}
catch (Exception ex)
{
return(new ServiceResponse <Brand>($"An Error Occured While Updating The Brand. {ex.Message}"));
}
}
public ActionResult <UpdateBrandResponse> PutBrand(UpdateBrandRequest request)
{
var response = _service.EditBrand(request);
return(response);
}
public Task <UpdateBrandResponse> UpdateBrand([FromBody] UpdateBrandRequest request) => _mediator.Send(request);
public ActionResult <UpdateBrandResponse> PutBrand(UpdateBrandRequest updateBrandRequest)
{
var updateBrandResponse = _brandService.EditBrand(updateBrandRequest);
return(updateBrandResponse);
}
