public HttpStatusCode UpdateCategory(int categoryId, UpdateCategoryDto updateCategoryDto)
{
if (categoryId <= 0)
{
return(HttpStatusCode.NotFound);
}
Catalog catalog = _ctx.Catalogs.FirstOrDefault(f => f.Id == updateCategoryDto.CatalogId);
Category category = _ctx.Categories.FirstOrDefault(f => f.Id == categoryId);
category.Name = updateCategoryDto.CategoryName;
category.IsPublished = updateCategoryDto.IsPublished;
category.LastModifiedDate = DateTime.Now;
category.CatalogId = catalog.Id;
category.Catalog = catalog;
try
{
_ctx.Entry(category).State = EntityState.Modified;
_ctx.SaveChanges();
return(HttpStatusCode.OK);
}
catch (Exception ex)
{
return(HttpStatusCode.InternalServerError);
}
}
public async Task <IActionResult> EditCategory(UpdateCategoryModel model)
{
var categories = await _solutionApiClient.GetAllCategoriesAsync();
ViewBag.Categories = categories.Data;
var dto = new UpdateCategoryDto
{
Id = model.Id,
Name = model.Name,
Description = model.Description,
ParentCategoryId = model.ParentCategoryId
};
var ph = model.Logo;
byte[] p1 = null;
using (var fs1 = ph.OpenReadStream())
using (var ms1 = new MemoryStream())
{
fs1.CopyTo(ms1);
p1 = ms1.ToArray();
}
dto.Logo = new NewPhotoDto {
Data = p1, Type = "Logo"
};
var updated_cat = await _solutionApiClient.UpdateCategoryAsync(dto);
return(Redirect("addCategory"));
}
/// <summary>
/// Обновить категорию
/// </summary>
/// <param name="dto"></param>
/// <returns></returns>
public async Task <CategoryDto> UpdateCategoryAsync(UpdateCategoryDto dto)
{
var cat = await _categoryRepository.GetAsync(dto.Id);
if (dto.Name != null)
{
cat.Name = dto.Name;
}
if (dto.Description != null)
{
cat.Description = dto.Description;
}
if (dto.ParentCategoryId != null)
{
cat.ParentCategoryId = dto.ParentCategoryId;
}
if (dto.Logo != null)
{
if (cat.Logo != null)
{
cat.Logo.Data = dto.Logo.Data;
}
else
{
cat.Logo = _mapper.Map <Photo>(dto.Logo);
}
}
await _categoryRepository.SaveChangesAsync();
return(_mapper.Map <CategoryDto>(cat));
}
public async Task <Category> UpdateAsync(int id, UpdateCategoryDto categoryToUpdate)
{
if (id < 1)
{
throw new ArgumentOutOfRangeException(nameof(id), id, "Id cannot be lower than 1.");
}
if (categoryToUpdate == null)
{
throw new ArgumentNullException(nameof(categoryToUpdate));
}
if (categoryToUpdate.Name.Length > 35)
{
throw new ArgumentOutOfRangeException(nameof(categoryToUpdate.Name), categoryToUpdate.Name, "Category name length cannot be greater than 35.");
}
if (!await _categoriesRepository.ExistsById(id))
{
throw new DataNotFoundException($"Category Id:{id} doesn't exists.");
}
if (await _categoriesRepository.ExistsByName(categoryToUpdate.Name))
{
throw new ArgumentException(nameof(categoryToUpdate.Name), $"Category {categoryToUpdate.Name} already exists.");
}
return(await _categoriesRepository.UpdateAsync(id, categoryToUpdate));
}
public async Task <Result> Update(UpdateCategoryDto updateCategoryDto)
{
var category = await FirstOrDefaultAsync(c => c.Id == updateCategoryDto.Id);
if (category == null)
{
return(Result.Failed(new BadRequestObjectResult(new ApiMessage
{
Message = ResponseMessage.InvalidCategoryId
})));
}
var duplicatedCategory =
await FirstOrDefaultAsyncAsNoTracking(c =>
c.Name == updateCategoryDto.Name && c.Id != updateCategoryDto.Id);
if (duplicatedCategory != null)
{
return(Result.Failed(new BadRequestObjectResult(new ApiMessage
{
Message = ResponseMessage.DuplicateCategoryName
})));
}
_mapper.Map(updateCategoryDto, category);
await Context.SaveChangesAsync();
return(Result.SuccessFull());
}
public static Category ToEntity(this UpdateCategoryDto source, int?parentId)
{
return(new Category
{
Id = source.Id,
Title = source.Title,
ParentId = parentId
});
}
public async Task <CategoryDto> UpdateCategory(UpdateCategoryDto input) //update category
{
var category = await _categoryRepo.GetAsync(input.Id);
category.Update(input.Type);
var result = await _categoryRepo.Update(category);
return(_mapper.Map <Category, CategoryDto>(result));
}
public async Task <IActionResult> Update(int id, [FromBody] UpdateCategoryDto dto)
{
var model = this.mapper.Map <UpdateCategoryModel>(dto);
model.Id = id;
var created = await this.categoryService.UpdateAsync <CategoryDto>(model);
return(this.Ok(created));
}
public async Task <Category> UpdateAsync(int id, UpdateCategoryDto categoryToUpdate)
{
var category = await _context.Categories.FirstAsync(c => c.Id == id);
category.Name = categoryToUpdate.Name;
await _context.SaveChangesAsync();
return(category);
}
public IActionResult Edit(Guid id, UpdateCategoryDto categoryDto)
{
if (ModelState.IsValid && id == categoryDto.Id)
{
var category = mapper.Map <Category>(categoryDto);
repository.Update(category);
return(StatusCode(200));
}
return(BadRequest());
}
public async Task <IActionResult> UpdateAsync(int id, [FromBody] UpdateCategoryDto item)
{
item.Id = id;
Category entity = _mapper.Map <Category>(item);
_categoryRepository.Update(entity);
await _categoryRepository.SaveChangesAsync();
return(Ok(_mapper.Map <GetCategoryDto>(entity)));
}
public async Task <CategoryViewModel> UpdateCategoryAsync(string categoryId,
UpdateCategoryDto updateCategoryDto)
{
Category category = await GetCategoryEntityAsync(categoryId);
category.Name = updateCategoryDto.Name;
await _categoryRepository.UpdateAsync(category);
return(_mapper.Map <CategoryViewModel>(category));
}
public async Task <IActionResult> Update([FromBody] UpdateCategoryDto category)
{
var response = await _service.UpdateCategoryAsync(category);
if (!response.Success)
{
return(BadRequest(response));
}
return(Ok(response));
}
public async Task <IActionResult> Update(int id, [FromBody] UpdateCategoryDto updateCategoryDto)
{
updateCategoryDto.Id = id;
var result = await _unitOfWork.CategoryService.Update(updateCategoryDto);
if (!result.Success)
{
return(result.ApiResult);
}
return(NoContent());
}
public async Task <IActionResult> UpdateCategory(UpdateCategoryDto updatedCategory)
{
ServiceResponse <GetCategoryDto> response = await _categoryService.UpdateCategory(updatedCategory);
if (response.Data == null)
{
return(NotFound(response));
}
return(Ok(response));
}
public IActionResult UpdateCategory([FromBody] UpdateCategoryDto updateCategory)
{
var result = _categoryService.UpdateCategory(updateCategory);
if (!result.IsSuccess)
{
return(BadRequest(result));
}
return(Ok(result.Response));
}
public async Task <IActionResult> Update(UpdateCategoryDto updateCategoryDto)
{
var updateCategoryViewModel = CustomMapper.GetUpdateCategoryViewModel(updateCategoryDto);
var result = await _categoryService.Update(updateCategoryViewModel);
if (result.IsValid)
{
return(Ok());
}
return(BadRequest(result.Errors));
}
public async Task <Category> UpdateCategory(UpdateCategoryDto updatedcategory)
{
using (var context = new DataBaseContext())
{
Category category = await context.Categories.FirstOrDefaultAsync(s => s.Id == updatedcategory.Id);
category.CategoryName = updatedcategory.CategoryName;
context.Categories.Update(category);
await context.SaveChangesAsync();
return(category);
}
}
public void Put()
{
var target = new CategoriesController(this._EFCategoryRepository, this._EFProductCategoryRepository, this._MockMapper);
var modifyCategory = new UpdateCategoryDto
{
CategoryName = "TestCategory01_Modified"
};
var result = target.Put(9, modifyCategory);
var okResult = result as OkObjectResult;
Assert.Equal(200, okResult.StatusCode);
Assert.Equal(9, this._EFCategoryRepository.Categories.Count());
Assert.Equal("TestCategory01_Modified", this._EFCategoryRepository.Categories.Where(c => c.CategoryId == 9).FirstOrDefault().CategoryName.ToString());
}
public async Task <IActionResult> UpdateAsync([FromRoute] int id, [FromBody] UpdateCategoryDto model)
{
try
{
return(Ok(await _categoriesService.UpdateAsync(id, model)));
}
catch (DataNotFoundException ex)
{
return(NotFound(ex.Message));
}
catch (ArgumentException ex)
{
return(BadRequest(ex.Message));
}
}
public HttpStatusCode UpdateCategory(int categoryId, UpdateCategoryDto updateCategoryDto)
{
var response = _categoryRepository.UpdateCategory(categoryId, updateCategoryDto);
switch (response)
{
case HttpStatusCode.OK:
return(HttpStatusCode.OK);
case HttpStatusCode.InternalServerError:
return(HttpStatusCode.InternalServerError);
default:
return(HttpStatusCode.NotFound);
}
}
public async Task <HttpResponseMessage> UpdateCategory(UpdateCategoryDto category)
{
Response <Entities.Entities.Category> httpResponse = new Response <Entities.Entities.Category>();
try
{
httpResponse.RequestState = true;
httpResponse.ErrorState = !await _categoryManager.UpdateCategory(category.Adapt <Entities.Entities.Category>());
}
catch (Exception ex)
{
httpResponse.ErrorState = true;
httpResponse.ErrorList.Add(ex.Adapt <ApiException>());
}
return(httpResponse);
}
public IHttpActionResult Put(int id, [FromBody] UpdateCategoryDto dto)
{
if (dto == null || ModelState.IsValid == false || id != dto.Id)
{
return(BadRequest());
}
var existingCategory = repo.GetById(id);
if (existingCategory == null)
{
return(NotFound());
}
existingCategory.Name = dto.Name;
repo.Update(existingCategory);
return(StatusCode(HttpStatusCode.NoContent));
}
public async Task <IActionResult> Update([FromRoute] string categoryId,
[FromBody] UpdateCategoryDto updateCategoryDto)
{
AuthorizationResult authorizationResult =
await _authorizationService.AuthorizeAsync(User, PolicyConstants.ManageCategoryRolePolicy);
if (!authorizationResult.Succeeded)
{
return(ActionResults.UnauthorizedResult(User.Identity.IsAuthenticated));
}
return(Ok(new Response <CategoryViewModel>
{
Data = await _mediator.Send(new UpdateCategoryCommand(categoryId, updateCategoryDto)),
}));
}
public async Task <ActionResult> UpdateCategory([FromBody] UpdateCategoryDto viewRequest)
{
if (!TryValidateModel(viewRequest))
{
return(BadRequest(ValidationHelper.GetModelErrors(ModelState)));
}
var request = this._mapper.Map <UpdateCategoryRequest>(viewRequest);
request.UserName = HttpContext.User.Identity.Name;
var command = new UpdateCategoryCommand
{
Data = request
};
return(await Go(command));
}
public async Task <ActionResult> UpdateCategoryAsync(Guid CategoryId, UpdateCategoryDto categoryToUpdate)
{
var existingCategory = await _categoriesRepository.GetCategoryAsync(CategoryId);
if (existingCategory is null)
{
return(NotFound());
}
Category updatedCategory = existingCategory;
updatedCategory.Name = categoryToUpdate.Name;
await _categoriesRepository.UpdateCategoryAsync(updatedCategory);
return(NoContent());
}
public async Task <HttpResponseMessage> UpdateCategory(UpdateCategoryDto category)
{
_logger.LogDebug("UpdateCategory init with", category);
Response <Entities.Entities.Category> httpResponse = new Response <Entities.Entities.Category>();
try
{
httpResponse.RequestState = true;
httpResponse.ErrorState = !await _categoryManager.UpdateCategory(category.Adapt <Entities.Entities.Category>());
}
catch (Exception ex)
{
_logger.LogError("UpdateCategory Error", ex);
httpResponse.ErrorState = true;
httpResponse.ErrorList.Add(ex.Adapt <ApiException>());
}
_logger.LogDebug("UpdateCategory end with", httpResponse);
return(httpResponse);
}
public async Task UpdateCategoryAsync(int userId, UpdateCategoryDto categoryDto)
{
var categories = GetUserCategories(userId);
var categoryToUpdate = FindCategory(categories, categoryDto.CategoryId);
if (categoryToUpdate is MainCategory mainCategory)
{
Mapper.Map(categoryDto, mainCategory);
categoryToUpdate = mainCategory;
}
else
{
Mapper.Map(categoryDto, categoryToUpdate);
var parentCategory = (categoryToUpdate as Subcategory).Parent;
categoryToUpdate = parentCategory;
}
UnitOfWork.CategoryRepository.Update((MainCategory)categoryToUpdate);
await UnitOfWork.CommitAsync();
}
public ServiceResult <UpdateCategoryDto> UpdateCategory(UpdateCategoryDto categoryDto)
{
var validateCategoryBaseDto = _fluentValidatorCategory.Validate(categoryDto);
var userModify = _categoryContext.Categories.FirstOrDefault(x => x.Id == categoryDto.Id);
if (!validateCategoryBaseDto.IsValid ||
userModify == null)
{
return(_mapper.Map <ServiceResult <UpdateCategoryDto> >(validateCategoryBaseDto.ToServiceResult <UpdateCategoryDto>(null)));
}
userModify.Description = categoryDto.Description;
userModify.Name = categoryDto.Name;
userModify.IsDeleted = categoryDto.IsDeleted;
userModify.Advance = categoryDto.Advance;
_categoryContext.Categories.Update(userModify);
_categoryContext.SaveChanges();
return(new ServiceResult <UpdateCategoryDto>(categoryDto));
}
public async Task <IActionResult> EditCategory(int id)
{
UpdateCategoryDto categoryToUpdate = await _db.Categories.Where(c => c.CategoryId == id)
.Select(c => new UpdateCategoryDto
{
CategoryId = c.CategoryId,
Description = c.Description,
Name = c.Name,
ParentCategoryId = c.ParentCategoryId,
}).FirstOrDefaultAsync();
if (categoryToUpdate is null)
{
return(NotFound());
}
ViewBag.ParentCategories = await _categoryService.GetParentCategoriesInSelectList();
return(View(categoryToUpdate));
}
