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="model">类别模型</param>
/// <returns>是否修改成功</returns>
public ResultModel UpdateCategory(UpdateCategoryModel model)
{
var result = new ResultModel();
using (var tx = this._database.Db.BeginTransaction())
{
try
{
tx.Category.Update(model);
foreach (var languageModel in model.Category_Lang)
{
languageModel.CategoryId = model.CategoryId.Value;
if (languageModel.Id != 0)
{
tx.Category_Lang.Update(languageModel);
}
else
{
tx.Category_Lang.Insert(languageModel);
}
}
tx.Commit();
}
catch (Exception)
{
tx.Rollback();
throw;
}
}
return(result);
}
public void UpdateCategory_ReturnUpdateItem_WhenStateIsValidAndCategoryExist()
{
//Arrange
var dbContext = new DocumentDbContext();
dbContext.Categories = GetQueryableMockDbSetCategory();
var categoryRepo = new CategoryRepo(string.Empty, dbContext);
var controller = new CategoryController(categoryRepo);
UpdateCategoryModel updateCategoryModel = new UpdateCategoryModel()
{
Id = 1,
Title = "Khoa Học"
};
//Act
var result = controller.UpdateCategory(updateCategoryModel);
//Assert
Assert.IsType <OkObjectResult>(result);
var okObjectResult = result as OkObjectResult;
Assert.IsType <Category>(okObjectResult.Value);
var categoryObject = okObjectResult.Value as Category;
Assert.Equal(categoryObject.Id, updateCategoryModel.Id);
Assert.Equal(categoryObject.Title, updateCategoryModel.Title);
}
public static Category GetEntity(UpdateCategoryModel model)
{
return(new Category
{
Name = model.Name
});
}
public async Task <CustomResponse> Update(Guid id, UpdateCategoryModel UpdateRequest)
{
CategoryDto categoryDto = _unitOfWork.CategoryRepository.Find(id);
if (categoryDto == null)
{
return(_responsMessages.CategoryNotFound);
}
categoryDto.Name = UpdateRequest.Name;
categoryDto.Description = UpdateRequest.Description;
categoryDto.Parent = UpdateRequest.Parent;
if (categoryDto.Parent != null)
{
CategoryDto parent = _unitOfWork.CategoryRepository.Find(categoryDto.Parent);
if (parent == null)
{
return(_responsMessages.CategoryParentNotFound);
}
}
await _unitOfWork.SaveChangesAsync();
return(_responsMessages.CategoryUpdatedSuccessfully);
}
public static ReadCategoryModel GetReadAchievementModel(UpdateCategoryModel model)
{
return(new ReadCategoryModel
{
Id = Guid.NewGuid(),
Name = model.Name
});
}
public async Task <IActionResult> UpdateCategoryAsync(int id, UpdateCategoryModel category)
{
category.CategoryId = id;
var updateCategoryDto = Mapper.Map <UpdateCategoryDto>(category);
await categoryService.UpdateCategoryAsync(GetUserId(), updateCategoryDto);
return(NoContent());
}
public async Task <TResult> UpdateAsync <TResult>(UpdateCategoryModel model)
{
var updatedEntity = this.mapper.Map <Category>(model);
this.categoryRepository.Update(updatedEntity);
await this.categoryRepository.SaveAsync();
return(await GetAsync <TResult>(updatedEntity.Id));
}
public async Task <ActionResult <CategoryDto> > UpdateCategory([FromForm] UpdateCategoryModel categoryModel)
{
var result = await _mediator.Send(new UpdateCategoryCommand
{
CategoryDto = _mapper.Map <CategoryDto>(categoryModel),
Photo = categoryModel.Photo != null ? new FileAdapter(categoryModel.Photo) : null
});
return(Ok(result));
}
public async Task <IActionResult> PatchCategory([FromBody] UpdateCategoryModel model, [FromRoute][Required] int id)
{
var command = Mapper.Map <CommandCategoryUpdate>(model);
command.Id = id;
var result = await Mediator.Send(command);
return(Ok(result.Id));
}
public IActionResult updateCategory([FromBody] UpdateCategoryModel updatedCategory)
{
try
{
var categoryToUpdate = _mapper.Map <Category>(updatedCategory);
_categoryService.updateCategory(categoryToUpdate);
return(Ok("Category has been successfully updated"));
}
catch (AppException ex)
{ return(BadRequest(new { message = ex.Message })); }
}
public Category UpdateCategory(string id, UpdateCategoryModel model)
{
Category category = new Category
{
Id = id,
Name = model.Name
};
_repository.Update(category);
return(category);
}
public IActionResult Update(int id)
{
var category = _categoryRepository.GetwithId(id);
UpdateCategoryModel guncellenecekVeri = new UpdateCategoryModel
{
Id = category.Id,
Name = category.Name
};
return(View(guncellenecekVeri));
}
public async Task <ActionResult> Put(int id, [FromBody] UpdateCategoryModel categoryBody)
{
if (!(await _authorizationService.AuthorizeAsync(User, id, "EditCategory")).Succeeded)
{
return(Forbid());
}
var categoryResource = _mapper.Map <UpdateCategoryResource>(categoryBody);
await _categoryService.UpdateCategory(id, categoryResource);
return(NoContent());
}
public ActionResult Update(UpdateCategoryModel model)
{
model.UpdateBy = UserInfo.CurrentUserName;
model.UpdateDT = DateTime.Now;
var result = this._categoryService.UpdateCategory(model);
var opera = string.Format("修改商品分类:{0},操作结果:{1}", JsonConverts.ToJson(model), result.Messages);
LogPackage.InserAC_OperateLog(opera, "商品分类-修改");
return(this.Json(result));
}
public async Task <ReadCategoryModel> UpdateCategoryAsync(UpdateCategoryModel model, Guid id, CancellationToken cancellationToken)
{
var category = await _categoryRepository.GetByIdAsync(id, cancellationToken);
category.Name = model.Name;
category.IconId = await _fileService.AddOrUpdateFileByIdAsync(model.Icon, category.IconId, cancellationToken);
_categoryRepository.Update(category);
await _unitOfWork.SaveChangesAsync(cancellationToken);
return(_mapper.Map <ReadCategoryModel>(category));
}
public async Task <bool> UpdateCategory([FromBody] UpdateCategoryModel model)
{
var result = false;
if (model.Parent.Equals(0))
{
result = await Category.UpdateCategory(model.ID, model.Name, model.Description);
}
else
{
result = await SubCategory.UpdateSubCategory(model.ID, model.Parent, model.Name, model.Description);
}
return(result);
}
public async Task <IActionResult> Post([FromBody] UpdateCategoryModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var category = _mapper.Map <Category>(model);
category = await _categoryService.Create(category);
var view = _mapper.Map <CategoryModel>(category);
return(Ok(view));
}
public async Task <IHttpActionResult> UpdatePosition([FromBody] UpdateCategoryModel data)
{
Code status = default(Code);
var position = store
.Positions
.Where(c => c.PositionID == data.id)
.FirstOrDefault();
if (position != null)
{
position.Name = data.name;
position.Description = data.description;
}
store.SaveChanges();
return(Ok(ApiResponseManager.CreateResponse(new Status(status))));
}
public async Task <IActionResult> UpdateCategoryAsync(int id, UpdateCategoryModel model)
{
if (GetUserId() != model.UserId || id != model.CategoryId)
{
var forbidden = new ForbiddenResponse();
return(StatusCode(forbidden.Status, forbidden));
}
if (ModelState.IsValid)
{
var result = await _updateCategoryCommand.RunAsync(model);
return(StatusCode(result.Status, result.Payload));
}
return(new BadRequestObjectResult(new BadRequestResponse(ModelState)));
}
public IActionResult Put(string id, [FromBody] UpdateCategoryModel model)
{
try
{
var category = _service.UpdateCategory(id, model);
return(Ok(category));
}
catch (Exception ex)
{
return(new ContentResult
{
StatusCode = StatusCodes.Status500InternalServerError,
Content = ex.Message,
ContentType = "text/plain",
});
}
}
public async Task <IHttpActionResult> UpdateCategory([FromBody] UpdateCategoryModel data)
{
Code status = default(Code);
var category = store
.Categories
.Where(c => c.CategoryID == data.id)
.FirstOrDefault();
if (category != null)
{
category.Name = data.name;
category.Description = data.description;
category.CellFrom = data.cellfrom;
category.CellTo = data.cellto;
}
store.SaveChanges();
return(Ok(ApiResponseManager.CreateResponse(new Status(status))));
}
public async Task <ActionResult> SubmitUpdateCategory(UpdateCategoryModel model)
{
if (ModelState.IsValid)
{
using (var context = new ApplicationDbContext())
{
var category = await context.ForumCategories.FirstOrDefaultAsync(x => x.Id == model.CategoryId && !x.IsDeleted);
if (category != null)
{
category.Name = model.Title;
category.Description = model.Description;
category.Order = model.Order;
await context.SaveChangesAsync().ConfigureAwait(false);
}
}
}
return(RedirectToAction("Category", new { id = model.CategoryId }));
}
public IActionResult Update(UpdateCategoryModel model)
{
if (ModelState.IsValid)
{
var company = _categoryRepository.GetwithId(model.Id);
company.Id = model.Id;
company.Name = model.Name;
_categoryRepository.Update(company);
return(RedirectToAction("index", "category"));
}
return(View(model));
}
public async Task <int> UpdateAsync(UpdateCategoryModel model)
{
_logger.LogInformation($"Updating Category: {model.CategoryId}");
var category = await _unitOfWork.CategoryRespository.GetByIdAsync(model.CategoryId);
if (category.Name.ToUpper().Equals(model.Name.ToUpper()))
{
return(model.CategoryId);
}
var categoryExists = await _unitOfWork
.CategoryRespository
.DoesCategoryExistAlready(model.Name);
if (categoryExists)
{
_logger.LogError($"Category already exists: {model.Name}");
ValidationErrors = new ModelStateDictionary();
ValidationErrors.AddModelError(NAME_PROPERTY, "Category already exists.");
return(ERROR_CODE);
}
category.Name = model.Name.CapitalizeFirstLetter();
try
{
_unitOfWork.CategoryRespository.Update(category);
var result = await _unitOfWork.SaveChangeAsync();
_logger.LogInformation($"Category updated: {model.Name}");
return(model.CategoryId);
}
catch (Exception ex)
{
_logger.LogWarning($"Exception updating Category: {model.Name} " +
$"|| {ex.Message} " +
$"|| {ex.StackTrace}");
throw new Exception("Create Category Exception", ex);
}
}
public async Task <IActionResult> Put(int id, [FromBody] UpdateCategoryModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var category = await _categoryService.GetByIdAsync(id);
if (category == null)
{
return(NotFound());
}
category = _mapper.Map(model, category);
category = await _categoryService.Update(category);
var view = _mapper.Map <CategoryModel>(category);
return(Ok(view));
}
public void UpdateCategory_ReturnNotFoundResult_WhenCategoryNotFound()
{
//Arrange
var dbContext = new DocumentDbContext();
dbContext.Categories = GetQueryableMockDbSetCategory();
var categoryRepo = new CategoryRepo(string.Empty, dbContext);
var controller = new CategoryController(categoryRepo);
UpdateCategoryModel updateCategoryModel = new UpdateCategoryModel()
{
Id = 3,
Title = "Khoa Học"
};
//Act
var result = controller.UpdateCategory(updateCategoryModel);
//Assert
Assert.IsType <NotFoundObjectResult>(result);
}
public async Task <IActionResult> UpdateCategoryAsync([FromForm] UpdateCategoryModel model, Guid categoryId, CancellationToken cancellationToken)
{
var category = await _categoryService.GetCategoryByIdAsync(categoryId, cancellationToken);
if (category == null)
{
return(NotFound());
}
var resultValidation = await _updateCategoryModelValidator.ValidateAsync(model, cancellationToken);
resultValidation.AddToModelState(ModelState, null);
if (!ModelState.IsValid)
{
return(UnprocessableEntity(ModelState));
}
var item = await _categoryService.UpdateCategoryAsync(model, categoryId, cancellationToken);
return(Ok(item));
}
public ActionResult UpdateLSP(UpdateCategoryModel update)
{
var findcategory = new CategoryDAO().FindCategory(update.Id);
string img;
if (update.Images != null)
{
img = update.Images;
}
else
{
img = findcategory.cateImage;
}
var category = new Category()
{
cateId = update.Id,
cateName = update.Name,
cateImage = img
};
var updatenew = new CategoryDAO().UpdateLSP(category);
return(RedirectToAction("Update", new { id = updatenew.cateId }));
}
public ActionResult Update(UpdateCategoryModel category)
{
if (!checkSession())
{
return(RedirectToAction("login", "users"));
}
CategoryDAO categoryDAO = new CategoryDAO();
if (categoryDAO.UpdateCategory(category))
{
return(Json(new
{
MESSAGE = "1"
}));
}
else
{
return(Json(new
{
MESSAGE = "0"
}));
}
//return View();
}
