public IActionResult Edit(int id)
{
var model = new CategoryUpdateModel();
model.Load(id);
return(View(model));
}
public async Task <CategoryUpdateModel> Update(CategoryUpdateModel model)
{
if (!_isAuthorized)
{
throw _eNotFound <CategoryUpdateModel>("Category not found");
}
Category entity = null;
if (string.IsNullOrWhiteSpace(model.Id))
{
entity = _mapper.Map <Category>(model);
}
else
{
entity = (await _repositoryCategory.GetFirst(x => x.Id == model.Id && x.State == MRApiCommon.Infrastructure.Enum.MREntityState.Active)
?? throw _eNotFound <CategoryUpdateModel>("Category not found"));
entity = _mapper.Map(model, entity);
}
entity = string.IsNullOrWhiteSpace(entity.Id)
? await _repositoryCategory.Insert(entity)
: await _repositoryCategory.Replace(entity);
return(_mapper.Map <CategoryUpdateModel>(entity));
}
protected void CheckUpdateModel(CategoryUpdateModel model)
{
if (model == null)
{
throw new ModelDamagedException(nameof(model), "is required");
}
if (string.IsNullOrWhiteSpace(model.Slug))
{
throw new ModelDamagedException(nameof(model.Slug), "is required");
}
if (model.Translations == null || !model.Translations.Any())
{
throw new ModelDamagedException(nameof(model.Translations), "is required");
}
if (model.Translations.Count(x => x.IsDefault) != 1)
{
throw new ModelDamagedException(nameof(model.Translations), "one must be default");
}
var damagedTranslation = model.Translations.FirstOrDefault(x => string.IsNullOrWhiteSpace(x.Name) || string.IsNullOrWhiteSpace(x.LanguageCode));
if (damagedTranslation != null)
{
throw new ModelDamagedException(nameof(model.Translations), "damaged");
}
if (model.Translations.GroupBy(x => x.LanguageCode).Any(x => x.Count() > 1))
{
throw new ModelDamagedException(nameof(model.Translations), "one must be default");
}
}
public IActionResult Delete(int id)
{
var model = new CategoryUpdateModel();
model.Delete(id);
return(RedirectToAction("Index"));
}
/// <summary>
///
/// </summary>
/// <param name="cat"></param>
/// <returns></returns>
public string UpdateCategoryDetail(CategoryUpdateModel cat)
{
Category catToUpdate = new Category();
string result;
if (cat == null)
{
result = "Input is null.";
return(result);
}
else if (string.IsNullOrEmpty(cat.CategoryName))
{
result = "Category Name should not be blank.";
return(result);
}
else
{
catToUpdate.Id = cat.Id;
catToUpdate.CategoryName = cat.CategoryName;
catToUpdate.IsActive = true;
catToUpdate.UpdateUserName = "******";
catToUpdate.UpdateDttm = DateTime.UtcNow;
result = _CategoryDataAccess.UpdateCategoryDetails(catToUpdate);
return(result);
}
}
public IActionResult Edit(CategoryUpdateModel model)
{
if (ModelState.IsValid)
{
model.EditCaregory();
}
return(View(model));
}
public async Task <Category> InsertAsync(CategoryUpdateModel Category)
{
var result = await this.Context.AddAsync(this.Mapper.Map <Category>(Category));
await this.Context.SaveChangesAsync();
return(this.Mapper.Map <Category>(result.Entity));
}
public ActionResult Add(CategoryUpdateModel model)
{
if (ModelState.IsValid)
{
model.AddNewCategory();
}
return(View(model));
}
public async Task UpdateAsync(CategoryUpdateModel model)
{
var jsonData = JsonConvert.SerializeObject(model);
var content = new StringContent(jsonData, Encoding.UTF8, "application/json");
_httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", _httpContextAccessor.HttpContext.Session.GetString("token"));
await _httpClient.PutAsync($"{model.Id}", content);
}
public IActionResult ViewCategoryDetails(int id, string error = "")
{
CategoryUpdateModel categoryUpdateModel = new CategoryUpdateModel {
category = _context.Categories.Find(id)
};
ViewBag.error = error;
return(View(categoryUpdateModel));
}
public async Task <IActionResult> Update(CategoryUpdateModel model)
{
if (ModelState.IsValid)
{
await _categoryApiService.UpdateAsync(model);
return(RedirectToAction("Index"));
}
return(View(model));
}
public async Task <IActionResult> Update(CategoryUpdateModel categoryUpdateModel)
{
TempData["active"] = "category";
if (ModelState.IsValid)
{
await _categoryApiService.UpdateAsync(categoryUpdateModel);
return(RedirectToAction("Index"));
}
return(View(categoryUpdateModel));
}
public static CategoryUpdateModel ToCategoryUpdateModel(Category dbModel)
{
var updateModel = new CategoryUpdateModel {
Id = dbModel.Id,
Name = dbModel.Name,
Description = dbModel.Description,
OldImageUrl = ToBase64String(dbModel.Image)
};
return(updateModel);
}
public Guid?Update(CategoryUpdateModel categoryUpdateModel)
{
var categoryEntityExisting = categoryRepository.GetById(categoryUpdateModel.Id);
categoryEntityExisting.Product = productRepository.GetByCategoryId(categoryUpdateModel.Id);
UpdateCategory(categoryUpdateModel, categoryEntityExisting);
var categoryEntityUpdated = mapper.Map <CategoryEntity>(categoryUpdateModel);
return(categoryRepository.Update(categoryEntityUpdated));
}
public async Task <IActionResult> Update(int id)
{
var result = await _categoryApiService.GetByIdAsync(id);
CategoryUpdateModel model = new CategoryUpdateModel
{
Id = result.Id,
Name = result.Name
};
return(View(model));
}
public void UpdateCategoryDetail_WhenCategoryModelInputIsNull_ReturnsInputIsNullError()
{
CategoryUpdateModel input = null;
Mock <ICategoryDataAccess> mockCategories = new Mock <ICategoryDataAccess>();
ICategoryBusinessLayer app = new CategoryBusinessLayer(mockCategories.Object);
var output = app.UpdateCategoryDetail(input);
Assert.AreEqual("Input is null.", output);
}
public ActionResult <CategoryReadModel> Update(int id, CategoryUpdateModel category)
{
var filteredCategory = _categoryService.GetById(id);
if (filteredCategory == null)
{
return(NotFound());
}
_mapper.Map(category, filteredCategory);
_categoryService.Update(filteredCategory);
// _categoryService.SaveChanges();
return(NoContent());
}
public IHttpActionResult UpdateCategory([FromBody] CategoryUpdateModel category)
{
var container = ContainerConfig.Configure();
using (var scope = container.BeginLifetimeScope())
{
var app = scope.Resolve <ICategoryBusinessLayer>();
var result = app.UpdateCategoryDetail(category);
return(Json(new { Result = result }));
}
}
public async Task CategoryUpdate(CategoryUpdateModel categoryUpdateModel)
{
var jsonData = JsonConvert.SerializeObject(categoryUpdateModel);
StringContent stringContent = new StringContent(jsonData, Encoding.UTF8, "application/json");
_httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", _httpContextAccessor.HttpContext.Session.GetString("token"));
var responseMessage = await _httpClient.PutAsync($"{categoryUpdateModel.Id}", stringContent);
if (responseMessage.IsSuccessStatusCode)
{
//return true;
}
//return flase;
}
public async Task <IActionResult> UpdateCategory(CategoryUpdateModel categoryUpdateModel)
{
var categoryToUpdate = await _categoriesRepository.GetAsync(categoryUpdateModel.Id);
if (categoryToUpdate == null)
{
return(NotFound());
}
_mapper.Map(categoryUpdateModel, categoryToUpdate);
await _categoriesRepository.SaveChangesAsync();
return(NoContent());
}
public async Task <IActionResult> Edit(int id)
{
ViewData["Active"] = "category";
var updatedCategory = await _categoryApiService.GetByIdAsync(id);
if (updatedCategory != null)
{
CategoryUpdateModel categoryUpdateModel = new CategoryUpdateModel
{
Id = updatedCategory.Id,
Name = updatedCategory.Name
};
return(View(categoryUpdateModel));
}
return(NotFound());
}
public static Category ToCategoryDbModel(CategoryUpdateModel updateModel)
{
var dbModel = new Category {
Id = updateModel.Id,
Name = updateModel.Name,
Description = updateModel.Description,
Image = FromFileForm(updateModel.NewImage)
};
if (dbModel.Image == null)
{
dbModel.Image = FromBase64String(updateModel.OldImageUrl);
}
return(dbModel);
}
public void UpdateCategoryDetail_WhenCategoryNameIsNullOrEmpty_ReturnsCategoryNameIsBlankError()
{
CategoryUpdateModel input = new CategoryUpdateModel()
{
CategoryName = string.Empty,
IsActive = true
};
Mock <ICategoryDataAccess> mockCategories = new Mock <ICategoryDataAccess>();
ICategoryBusinessLayer app = new CategoryBusinessLayer(mockCategories.Object);
var output = app.UpdateCategoryDetail(input);
Assert.AreEqual("Category Name should not be blank.", output);
}
public void Update(int id, CategoryUpdateModel category)
{
var _category = _typesRepository.Get(id);
if (_category == null)
{
throw new ApplicationException("Błąd, blad edycji");
}
_category.Update(category);
if (!_typesRepository.Update(_category))
{
throw new ApplicationException();
}
}
public async Task <IActionResult> update(CategoryUpdateModel category)
{
var Item = await _categoryRepo.GetCategory(category.CategoryId);
if (Item == null)
{
return(NotFound());
}
var model = new Category {
CategoryId = category.CategoryId,
name = category.name
};
await _categoryRepo.update(model);
return(Ok());
}
public async Task <IActionResult> Edit(int id, CategoryUpdateModel categoryUpdateModel)
{
TempData["active"] = "category";
if (id != categoryUpdateModel.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
await _categoryApiService.CategoryUpdate(categoryUpdateModel);
return(RedirectToAction(nameof(Index)));
}
return(View(categoryUpdateModel));
}
async public Task <IActionResult> Update(CategoryUpdateModel categoryUpdateModel)
{
if (ModelState.IsValid)
{
Console.WriteLine("Model valid!");
var dbModel = DataMapper.ModelMapper.ToCategoryDbModel(categoryUpdateModel);
_categoryRepository.Update(dbModel);
await _categoryRepository.SaveChangesAsync();
}
else
{
Console.WriteLine("Model invalid!");
return(View("Edit", categoryUpdateModel));
}
return(RedirectToAction("Index", "Home"));
}
public async Task <IActionResult> Put([FromBody] CategoryUpdateModel categoryUpdateModel)
{
CategoryDto categoryDto = await _categoryService.GetCategory(categoryUpdateModel.CategoryId);
if (categoryDto.Title != categoryUpdateModel.Title)
{
if (await _categoryService.Exists(categoryUpdateModel.Title))
{
return(Conflict("This category already exists"));
}
}
CategoryDto categoryUpdateDto = _mapper.Map <CategoryDto>(categoryUpdateModel);
CategoryDto updatedCategoryDto = await _categoryService.UpdateCategory(categoryUpdateDto);
return(CreatedAtAction(nameof(Get), new { id = updatedCategoryDto.CategoryId }, updatedCategoryDto));
}
public ActionResult Edit(int id, CategoryUpdateModel updateModel)
{
if (!ModelState.IsValid)
{
return(View(updateModel));
}
try
{
_categoryService.Update(id, updateModel);
}
catch (Exception e)
{
return(new HttpStatusCodeResult(500, e.Message));
}
return(RedirectToAction("Index"));
}
public void UpdateCategoryDetail_WhenCategoryModelInputIsCorrect_ReturnsSuccess()
{
CategoryUpdateModel input = new CategoryUpdateModel()
{
Id = 1,
CategoryName = "Furniture",
IsActive = true
};
Mock <ICategoryDataAccess> mockCategories = new Mock <ICategoryDataAccess>();
mockCategories.Setup(x => x.UpdateCategoryDetails(It.IsAny <Category>())).Returns("Category updated.");
ICategoryBusinessLayer app = new CategoryBusinessLayer(mockCategories.Object);
var output = app.UpdateCategoryDetail(input);
Assert.AreEqual("Category updated.", output);
}
