public async Task <BaseResponse> UpdateCategoryAsync(string Account, CategoryUpdateDto req)
{
var cate = await _cr.FindAsync(req.Id);
if (cate == null)
{
return(new BaseResponse {
Success = false, Message = "输入的分类标示不存在"
});
}
try
{
var dto = _map.Map(req, cate);
dto.Modify = Account;
dto.ModifyTime = DateTime.Now;
await _cr.SaveAsync(dto);
_log.LogInformation($"{Account}修改标示为{req.Id}的分类数据成功");
return(new BaseResponse {
Success = true, Message = "修改数据成功"
});
}
catch (Exception ex)
{
_log.LogError($"{Account}修改标示为:{req.Id}的分类数据失败，失败原因:{ex.Message}->{ex.StackTrace}->{ex.InnerException}");
return(new BaseResponse {
Success = false, Message = "修改数据失败，请联系管理员"
});
}
}
public async Task <ActionResult <BaseResponse> > UpdateCategory([FromBody] CategoryUpdateDto req)
{
string Account = User.Claims.FirstOrDefault(a => a.Type == "Account").Value;
var rm = await _cs.UpdateCategoryAsync(Account, req);
return(rm);
}
public void UpdateCategory_WhenSystemErrorOccurredShouldReturn500StatusCode()
{
Category obj = null;
var categoryUpdateDtoObj = new CategoryUpdateDto
{
CreationDateTime = DateTime.Now,
Description = "Opis nowy",
Id = 1,
Image = null,
Title = "Tytul Opisowy"
};
var categoryUpdateObj = new Category()
{
CreationDateTime = DateTime.Now,
Description = categoryUpdateDtoObj.Description,
ForumPosts = null,
Id = categoryUpdateDtoObj.Id,
Image = categoryUpdateDtoObj.Image,
Title = categoryUpdateDtoObj.Title
};
_mockMapper.Setup(map => map.Map <Category>(categoryUpdateDtoObj)).Returns(categoryUpdateObj);
_mockRepo.Setup(repo => repo.UpdateCategory(categoryUpdateObj)).Callback <Category>(x => obj = x).Returns(false);
_mockRepo.Setup(repo => repo.GetCategory(categoryUpdateDtoObj.Title)).Returns(categoryUpdateObj);
var result = _controller.UpdateCategory(1, categoryUpdateDtoObj);
var objectResult = Assert.IsType <ObjectResult>(result);
_mockRepo.Verify(repo => repo.GetCategory(categoryUpdateDtoObj.Title), Times.Once);
_mockRepo.Verify(repo => repo.UpdateCategory(categoryUpdateObj), Times.Once);
Assert.Equal(StatusCodes.Status500InternalServerError, objectResult.StatusCode);
}
public void UpdateCategory_WithCorrectDataShouldReturnNoContent()
{
Category obj = null;
var categoryUpdateDtoObj = new CategoryUpdateDto
{
CreationDateTime = DateTime.Now,
Description = "Opis nowy",
Id = 1,
Image = null,
Title = "Tytul Opisowy"
};
var categoryUpdateObj = new Category()
{
CreationDateTime = DateTime.Now,
Description = categoryUpdateDtoObj.Description,
ForumPosts = null,
Id = categoryUpdateDtoObj.Id,
Image = categoryUpdateDtoObj.Image,
Title = categoryUpdateDtoObj.Title
};
_mockMapper.Setup(map => map.Map <Category>(categoryUpdateDtoObj)).Returns(categoryUpdateObj);
_mockRepo.Setup(repo => repo.UpdateCategory(categoryUpdateObj)).Callback <Category>(x => obj = x).Returns(true);
_mockRepo.Setup(repo => repo.GetCategory(categoryUpdateDtoObj.Title)).Returns(categoryUpdateObj);
var result = _controller.UpdateCategory(1, categoryUpdateDtoObj);
_mockRepo.Verify(repo => repo.GetCategory(categoryUpdateDtoObj.Title), Times.Once);
_mockRepo.Verify(repo => repo.UpdateCategory(categoryUpdateObj), Times.Once);
Assert.IsType <NoContentResult>(result);
Assert.Equal(categoryUpdateObj.Title, obj.Title);
Assert.Equal(categoryUpdateObj.Description, obj.Description);
}
public async Task <IResult> Update(CategoryUpdateDto categoryUpdateDto, string modifiedByName)
{
var result = await _unitOfWork.Categories.AnyAsync(c => c.Id == categoryUpdateDto.Id);
if (result)
{
var category = _mapper.Map <Category>(categoryUpdateDto);
category.ModifiedByName = modifiedByName;
await _unitOfWork.Categories.UpdateAsync(category).ContinueWith(t => _unitOfWork.SaveAsync());
return(new Resulst(ResultStatus.Success, $"{categoryUpdateDto.Name} adlı kategori başarıyla güncellendi."));
}
//{
// category.Name = categoryUpdateDto.Name;
// category.Description = categoryUpdateDto.Description;
// category.Note = categoryUpdateDto.Note;
// category.IsActive = categoryUpdateDto.IsActive;
// category.IsDeleted = categoryUpdateDto.IsDeleted;
// category.ModifiedByName = modifiedByName;
// category.ModifiedDate = DateTime.Now;
// await _unitOfWork.Categories.UpdateAsync(category).ContinueWith(t => _unitOfWork.SaveAsync());
// return new Resulst(ResultStatus.Success, $"{categoryUpdateDto.Name} adlı kategori başarıyla güncellendi.");
//}
return(new Resulst(ResultStatus.Error, "Böyle bir kategori bulunamadı"));
}
public async Task <IActionResult> UpdateCategory([FromBody] CategoryUpdateDto cat, int id)
{
if (!ModelState.IsValid || cat == null)
{
return(BadRequest(ModelState));
}
var catFromRepo = await _catRepo.Get(id);
if (catFromRepo == null)
{
return(NotFound());
}
var result = _mapper.Map(cat, catFromRepo);
var cantName = _catRepo.FindByName(cat.CategoryName);
if (cantName > 0)
{
return(Conflict());
}
await _catRepo.UpdateAsync(result);
if (await _catRepo.SaveAll())
{
var catUpdated = _mapper.Map <CategoryUpdateDto>(result);
return(Ok(catUpdated));
}
throw new Exception($"Error updating category {id}");
}
public async Task <IActionResult> Update(CategoryUpdateDto categoryUpdateDto)
{
if (ModelState.IsValid)
{
var result = await _categoryService.UpdateAsync(categoryUpdateDto, LoggedInUser.UserName);
if (result.ResultStatus == ResultStatus.Success)
{
var categoryUpdateAjaxModel = JsonSerializer.Serialize(new CategoryAddAjaxViewModel
{
CategoryDto = result.Data,
CategoryAddPartial = await this.RenderViewToStringAsync("_CategoryUpdatePartial", categoryUpdateDto)
});
return(Json(categoryUpdateAjaxModel));
}
}
var categoryUpdateAjaxErrorModel = JsonSerializer.Serialize(new CategoryUpdateAjaxViewModel
{
CategoryUpdatePartial = await this.RenderViewToStringAsync("_CategoryAddPartial", categoryUpdateDto)
});
return(Json(categoryUpdateAjaxErrorModel));
}
public IActionResult Update([FromBody] CategoryUpdateDto categoryUpdateDto)
{
var oldCategory = _categoryService.GetByIdAsync(categoryUpdateDto.Id).Result;
var categoryUpdate = _mapper.Map <CategoryUpdateDto, Category>(categoryUpdateDto, oldCategory.Data);
var result = _categoryService.Update(categoryUpdate);
if (result.ResultStatus == ResultStatus.Error)
{
return(BadRequest(new ErrorDto
{
Message = ApiResultMessages.ResultMessage(false),
ResultStatus = result.ResultStatus
}));
}
return(Ok(new CategoryDto
{
Category = result.Data,
Message = ApiResultMessages.ResultMessage(true),
ResultStatus = result.ResultStatus
}));
}
public async Task <IActionResult> Update(CategoryUpdateDto categoryUpdateDto)
{
if (ModelState.IsValid)
{
//eğer eklenecek olan veride bir hata yoksa dn ye ekliyoruz daha sonra Success olan veriyi kull. tekrardan göst. icin
//Json'a donust. ve eklenen result verisinin datasını alıyoruz ve göst. olan sayfaya render ediyoruz.
var result = await _categoryService.Update(categoryUpdateDto, "Ahmet");
if (result.ResultStatus == ResultStatus.Success)
{
var categoryUpdateAjaxModel = JsonSerializer.Serialize(new CategoryUpdateAjaxViewModel()
{
CategoryDto = result.Data,
CategoryUpdatePartial = await this.RenderViewToStringAsync("_CategoryUpdatePartial", categoryUpdateDto)
});
return(Json(categoryUpdateAjaxModel));
}
}
var categoryUpdateAjaxErrorModel = JsonSerializer.Serialize(new CategoryUpdateAjaxViewModel()
{
CategoryUpdatePartial = await this.RenderViewToStringAsync("_CategoryUpdatePartial", categoryUpdateDto),
});
return(Json(categoryUpdateAjaxErrorModel));
}
public async Task <IDataResult <CategoryDto> > UpdateAsync(CategoryUpdateDto categoryUpdateDto, string modifiedByName) //update'de add'den farklı olarak id var ve bununla biz güncellenecek nesneyi çağırcaz
{
var oldCategory = await UnitOfWork.Categories.GetAsync(c => c.Id == categoryUpdateDto.Id);
var category = Mapper.Map <CategoryUpdateDto, Category>(categoryUpdateDto, oldCategory);
category.ModifiedByName = modifiedByName;
var updatedCategory = await UnitOfWork.Categories.UpdateAsync(category);
await UnitOfWork.SaveAsync();
return(new DataResult <CategoryDto>(ResultStatus.Success, Messages.Category.Update(updatedCategory.Name), new CategoryDto
{
Category = updatedCategory,
ResultStatus = ResultStatus.Success,
Message = Messages.Category.Update(updatedCategory.Name)
}));
//var category = await UnitOfWork.Categories.GetAsync(c => c.Id == categoryUpdateDto.Id);
//if (category != null)
//{
// //kullanıcıdan gelen
// category.Name = categoryUpdateDto.Name;
// category.Description = categoryUpdateDto.Description;
// category.Note = categoryUpdateDto.Note;
// category.IsActive = categoryUpdateDto.IsActive;
// category.IsDeleted = categoryUpdateDto.IsDeleted;
// //backend tarafı
// category.ModifiedByName = modifiedByName;
// category.ModifiedDate = DateTime.Now;
// await UnitOfWork.Categories.UpdateAsync(category).ContinueWith(t => UnitOfWork.SaveAsync());
// return new Result(ResultStatus.Success, $"{categoryUpdateDto.Name} adlı kategori başarıyla güncellenmiştir.");
//}
//return new Result(ResultStatus.Error, "Böyle bir kategori bulunamadı.");
}
public async Task <IDataResult <CategoryDto> > Update(CategoryUpdateDto categoryUpdateDto, string modifiedByName)
{
var category = _mapper.Map <Category>(categoryUpdateDto);
category.ModifiedByName = modifiedByName;
if (category != null)
{
var updatedCategory = await _unitOfWork.Categories.UpdateAsync(category);//.ContinueWith(t=>_unitOfWork.SaveAsync());Hemen ardından save işlemi yapılması için kullandık
await _unitOfWork.SaveAsync();
return(new DataResult <CategoryDto>(ResultStatus.Success, new CategoryDto
{
Category = updatedCategory,
ResultStatus = ResultStatus.Success,
Message = $"{updatedCategory.Name} adlı kategori başarıyla eklenmiştir"
}
, $"{updatedCategory.Name} adlı kategori başarıyla güncellenmiştir"));
}
return(new DataResult <CategoryDto>(ResultStatus.Error, new CategoryDto
{
Category = null,
ResultStatus = ResultStatus.Error,
Message = "Seçilen kategoriye ait bilgi bulunamamıştır"
}
, "Seçilen kategoriye ait bilgi bulunamamıştır"));
}
public int Update(CategoryUpdateDto prod, int categoryId)
{
using (IDbConnection dbConnection = Connection)
{
return(dbConnection.Execute(CategoryQueries.Update, new { prod.Name, prod.Description, id = categoryId }));
}
}
public async Task <IActionResult> PutCategory(int id, CategoryUpdateDto categoryUpdateDto)
{
var category = await _context.Categories.FindAsync(id);
if (category == null)
{
return(NotFound());
}
_mapper.Map(categoryUpdateDto, category);
_context.Entry(category).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync().ConfigureAwait(false);
}
catch (DbUpdateConcurrencyException)
{
if (!CategoryExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public IActionResult Update([FromBody] CategoryUpdateDto categoryUpdateDto)
{
CategoryUpdateCommand categoryUpdateCommand = MapService.Map(categoryUpdateDto);
Result result = _messages.Dispatch(categoryUpdateCommand);
return(FromResult(result));
}
public async Task <CategoryOutputDto> Put([FromBody] CategoryUpdateDto input)
{
var category = _mapper.Map <Category>(input);
var result = await _categoryManager.UpdateAsync(category);
return(_mapper.Map <CategoryOutputDto>(result));
}
public IResult Update(CategoryUpdateDto categoryUpdateDto, string modifeidByName)
{
var category = _mapper.Map <Category>(categoryUpdateDto);
category.ModifiedDate = DateTime.Now;
category.ModifiedByName = modifeidByName;
return(new Result(ResultStatus.Success, $"{categoryUpdateDto.Name} adlı kategori başarı ile güncellenmiştir"));
}
public bool Update(CategoryUpdateDto category, int categoryId)
{
if (_categoryRepository.Update(category, categoryId) != 0)
{
return(true);
}
return(false);
}
public ActionResult <Category> Update(CategoryUpdateDto CategoryUpdateDto)
{
try{
return(service.Update(CategoryUpdateDto));
} catch (Exception error) {
return(Conflict(error.Message));
}
}
public async Task <IResult> Update(CategoryUpdateDto categoryUpdateDto, string modifiedByName)
{
var category = _mapper.Map <Category>(categoryUpdateDto);
category.ModifiedByName = modifiedByName;
await _unitOfWork.Categories.UpdateAsync(category).ContinueWith(t => _unitOfWork.SaveAsync());
return(new Result(ResultStatus.Success, $"{categoryUpdateDto.Name} adlı kategori başarıyla güncellenmiştir."));
}
public IActionResult Update(int id, [FromForm] CategoryUpdateDto categoryUpdateDto)
{
if (id != categoryUpdateDto.Id)
{
return(BadRequest("geçersiz id"));
}
_categoryService.Update(_mapper.Map <Category>(categoryUpdateDto));
return(NoContent());
}
public async Task Update(int id, CategoryUpdateDto model)
{
var entry = await _context.Categories.SingleAsync(x => x.CategoryId == id);
entry.Name = model.Name;
entry.Description = model.Description;
await _context.SaveChangesAsync();
}
public IActionResult UpdateCategory(CategoryUpdateDto model)
{
if (ModelState.IsValid)
{
_categoryService.Update(_mapper.Map <Category>(model));
return(RedirectToAction("Index"));
}
return(View(model));
}
public async Task <IActionResult> Update(int id, [FromForm] CategoryUpdateDto model)
{
if (id != model.Id)
{
return(BadRequest("Geçersiz id"));
}
await categoryService.UpdateAsync(mapper.Map <Category>(model));
return(NoContent());
}
public async Task <IActionResult> UpdateCategory(CategoryUpdateDto categoryUpdateDto)
{
Category updatedCategory = await _categoryRepository.FindByIdAsync(categoryUpdateDto.CategoryId);
updatedCategory = _mapper.Map <Category>(categoryUpdateDto);
await _categoryRepository.UpdateAsync(updatedCategory);
return(BadRequest(updatedCategory));
}
public async Task <IActionResult> Update(int id, CategoryUpdateDto categoryUpdateDto)
{
if (id != categoryUpdateDto.CategoryId)
{
return(BadRequest("invalid id"));
}
await _categoryService.UpdateAsync(_mapper.Map <Category>(categoryUpdateDto));
return(NoContent());
}
public async Task <IActionResult> Edit(CategoryUpdateDto categoryUpdateDto)
{
if (ModelState.IsValid)
{
await _categoryService.Update(categoryUpdateDto, "Hasan Erdal");
return(RedirectToAction("Index"));
}
return(View(categoryUpdateDto));
}
public async Task <IActionResult> UpdateCategory(Guid id, CategoryUpdateDto categoryDto)
{
var categoryFromDb = await uow.categoryRepository.FindCategoryAsync(id);
categoryFromDb.updated_by = 2;
categoryFromDb.updated_on = DateTime.UtcNow;
mapper.Map(categoryDto, categoryFromDb);
await uow.SaveAsync();
return(Ok(categoryDto));
}
public async Task <IActionResult> UpdateCategoryAsync(int id, [FromBody] CategoryUpdateDto categoryUpdateDto)
{
var result = await _service.UpdateCategoryAsync(id, categoryUpdateDto);
if (!result)
{
return(BadRequest("Update failed!"));
}
return(NoContent());
}
public async Task <IActionResult> UploadCategoryImage([FromForm] CategoryUpdateDto updateCategoryModel)
{
var imageInMemory = new MemoryStream();
updateCategoryModel.CategoryImage.CopyTo(imageInMemory);
await _categoriesService.UpdateCategoryImageAsync
(updateCategoryModel.CategoryId, imageInMemory.ToArray());
return(NoContent());
}
public ActionResult UpdateCategory(int id, [FromBody] CategoryUpdateDto categoryUpdateDto)
{
var isUpdated = this._categoryService.UpdateCategory(id, categoryUpdateDto);
if (!isUpdated)
{
return(this.BadRequest());
}
return(this.NoContent());
}
