public IActionResult Edit(CategoryEditModel model)
{
if (ModelState.IsValid)
{
var c = CategoryRepository.Read(model.Id);
if (null == c)
{
return(NotFound());
}
var cat = new Category()
{
Id = model.Id,
Title = model.Title,
RouteName = model.RouteName,
Description = model.Description
};
var rows = CategoryRepository.Update(cat);
if (rows > 0)
{
return(RedirectToAction(nameof(Manage)));
}
ModelState.AddModelError(string.Empty, "Create Category Failed on Data Layer.");
}
return(View());
}
public async Task <IActionResult> FavoriteCatEdit(CategoryEditModel model)
{
if (ModelState.IsValid)
{
var result = await _selectItemsServices.UpdateCategory(model);
if (result)
{
SuccessNotification("The favorite category data has been updated successfully.");
return(RedirectToAction("FavoriteCatEdit", "SelectItems",
new { BOSOID = model.BosoId }));
}
else
{
ModelState.AddModelError("", "Something went wrong while saving record.");
}
}
//Redisplay Form
model = await _selectItemsServices.GetEditCategory(model.BosoId);
foreach (var item in (await _productManagementService.GetCategories((int)_workContext.CurrentCustomer.ClientId)))
{
model.AvailableCategories.Add(new SelectListItem {
Text = item.Category1, Value = item.Category1
});
}
return(View(model));
}
public async Task <IActionResult> UpdateCategory(CategoryEditModel model)
{
if (ModelState.IsValid)
{
try
{
var recCategory = await _context.Categories.FirstOrDefaultAsync(q => q.CategoryId == model.CategoryId);
// Get the category entity
var record = await _context.Categories.FirstOrDefaultAsync(q => q.CategoryId != model.CategoryId && q.Slug == model.Slug);
if (record == null)
{
// Update unmapped properties
recCategory.Name = model.Name;
recCategory.Slug = model.Slug;
recCategory.DateModified = DateTime.UtcNow;
// Update
_context.Categories.Update(recCategory);
await _context.SaveChangesAsync();
return(Json(new { success = true }));
}
ModelState.AddModelError("slug", "Slug must be unique");
}
catch
{
ModelState.AddModelError("", "An error occurred while updating the category");
}
}
return(PartialView("_CategoryRecord", model));
}
public async Task <IActionResult> Edit(CategoryEditModel model)
{
if (ModelState.IsValid)
{
var seller = await HttpContext.GetMemberAsync();
var category = await _categoryService.GetAsync(new CategoryFilter()
{
SellerId = seller.Id, CategoryId = model.Id
});
if (category != null)
{
await _appService.PrepareCategoryAsync(category, model);
category.SellerId = seller.Id;
await _categoryService.UpdateAsync(category);
await SaveCategoryImage(category, model);
await SaveCategoryTags(category, model);
TempData.AddAlert(AlertMode.Notify, AlertType.Success, $"\"{category.Name}\" category was updated.");
}
}
return(RedirectToAction(nameof(Index)));
}
public async Task <IActionResult> AddCategory(CategoryEditModel model)
{
if (ModelState.IsValid)
{
try
{
var category = _mapper.Map <Category>(model);
var record = await _context.Categories.FirstOrDefaultAsync(q => q.CategoryId != model.CategoryId && q.Slug == model.Slug);
if (record == null)
{
// Populate unmapped properties
category.Slug = model.Slug;
category.DateCreated = DateTime.UtcNow;
// Add
_context.Categories.Add(category);
await _context.SaveChangesAsync();
return(Json(new { success = true }));
}
ModelState.AddModelError("slug", "Slug must be unique");
}
catch
{
ModelState.AddModelError("", "An error occurred while adding the category");
}
}
return(PartialView("_CategoryRecord", model));
}
public ActionResult Create(CategoryEditModel model)
{
if (ModelState.IsValid)
{
try
{
db.Category.Add(model.Category);
db.SaveChanges();
return(RedirectToAction("Index"));
}
catch (DbUpdateException dbex)
{
var ex = (SqlException)dbex.InnerException.InnerException;
foreach (SqlError error in ex.Errors)
{
if (error.Number == 50000)
{
ModelState.AddModelError("", error.Message);
}
}
}
}
model.CategorySelectList = GetCategorySelectLists(model.Category.ParentID);
return(View(model));
}
public async Task <IActionResult> Create([FromBody] CategoryEditModel category)
{
if (ModelState.IsValid)
{
CategoryResultModel response = await this.categoryService.UpdateCategory(category.Id, category.Name, category.Description);
if (!response.Success)
{
FailedResponseModel badResponse = new FailedResponseModel()
{
Errors = response.Errors
};
return(BadRequest(badResponse));
}
CategorySuccessResponseModel successResponse = new CategorySuccessResponseModel()
{
Name = response.Name
};
return(Ok(successResponse));
}
return(BadRequest(new FailedResponseModel {
Errors = ModelState.Values.SelectMany(x => x.Errors.Select(y => y.ErrorMessage))
}));
}
public ActionResult Edit(int id, CategoryEditModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var category = moneyRepository.GetCategory(model.Id);
if (category == null)
{
return(NotFound());
}
if (category.UserId != CurrentUserId)
{
return(Unauthorized());
}
moneyRepository.UpdateCategory(new Category
{
Id = model.Id,
Name = model.Name,
Color = model.Color
});
return(Ok());
}
public ActionResult Edit(CategoryEditModel model)
{
if (ModelState.IsValid)
{
var category = db.Categories.Where(m => m.Id == model.Id)
.FirstOrDefault();
if (category != null)
{
category.Title = model.Title;
}
else
{
category = new Category
{
Title = model.Title
};
db.Categories.Add(category);
}
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(model));
}
public async Task PrepareModelAsync(CategoryEditModel model, Category category, User seller)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
if (category != null)
{
model = _mapper.Map(category, model);
model.TagNames.AddRange(category.Tags.Select(x => x.Name));
}
else
{
model.Published = true;
}
var tagNames = (await _tagService.ListAsync(new TagFilter()
{
SellerId = seller.Id
})).Select(x => x.Name).Distinct();
model.TagOptions.AddRange(SelectListHelper.GetSelectList(tagNames, x => new SelectListItem <string>(text: x, value: x)));
var icons = await GenerateFa5IconsAsync();
model.IconOptions.AddRange(SelectListHelper.GetSelectList(icons, x => new SelectListItem <string>(text: x.Humanize(LetterCasing.Title), value: x, selected: x == model.Icon), defaultText: "No Icon"));
}
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var category = this.Data.Categories.GetById(id);
if (category == null)
{
return(this.HttpNotFound());
}
var sections = this.Data.Sections.All().ProjectTo <SectionConciseViewModel>().ToList();
var model = new CategoryEditModel
{
Id = category.Id,
Title = category.Title,
Description = category.Description,
SectionId = category.SectionId,
IsDeleted = category.IsDeleted,
Sections = new SelectList(sections, "Id", "Title", category.SectionId)
};
return(this.View(model));
}
public ActionResult Add(CategoryEditModel model)
{
var newCategory = new Category
{
Name = model.Name,
FriendlyUrl = model.FriendlyUrl,
MetaTitle = model.MetaTitle,
MetaDescription = model.MetaDescription,
MetaKeyWords = model.MetaKeyWords
};
if (this.ShopData.Categories.All().Any(c => c.FriendlyUrl == model.FriendlyUrl || c.Name == model.Name))
{
this.ModelState.AddModelError(string.Empty, string.Format("Seo Friendly Url & Name must be unique!"));
}
if (this.ModelState.IsValid)
{
this.ShopData.Categories.Add(newCategory);
this.ShopData.SaveChanges();
this.ClearCache();
return(this.RedirectToAction("Index"));
}
return(this.View(model));
}
public ActionResult Create()
{
var viewModel = new CategoryEditModel
{
Category = new CategoryDto()
};
return(View(viewModel));
}
public ActionResult EditCategory(int id)
{
var model = new CategoryEditModel
{
Category = _categoryService.GetCategoryModel(id),
Categories = _categoryService.GetBaseProductCategories()
};
return(View("~/Areas/Admin/Views/Category/AddCategory.cshtml", model));
}
public async Task Update(string id, CategoryEditModel model)
{
Category category = this.context.Categories
.FirstOrDefault(s => s.Id == id);
model.To <Category>(category);
this.context.Categories.Update(category);
await this.context.SaveChangesAsync();
}
/// <summary>
/// Maps a CategoryEditModel into a specific Category
/// </summary>
/// <param name="item"></param>
/// <param name="category"></param>
/// <returns></returns>
public static Category MapToModel(this CategoryEditModel item, Category category)
{
category.Id = item.Id;
category.VanityId = item.VanityId;
category.Name = item.Name;
category.Description = item.Description;
category.Slug = item.Slug;
return(category);
}
public async Task <IActionResult> CreateAsync(CategoryEditModel categoryEditModel)
{
if (!ModelState.IsValid)
{
SetupMessages("Categories", PageType.Create, panelTitle: "Create a new category");
return(View("CreateEdit", categoryEditModel));
}
return(await SaveAsync(categoryEditModel, nameof(CategoryController.Create)));
}
public async Task <IActionResult> Add()
{
var seller = await HttpContext.GetMemberAsync();
var model = new CategoryEditModel();
await _appService.PrepareModelAsync(model, null, seller);
return(View(nameof(Edit), model));
}
/// <summary>
/// Maps a CategoryEditModel into a Category
/// </summary>
/// <param name="item"></param>
/// <returns></returns>
public static Category MapToModel(this CategoryEditModel item)
{
return(new Category
{
Id = item.Id,
VanityId = item.VanityId,
Name = item.Name,
Description = item.Description,
Slug = item.Slug,
});
}
public async Task <IActionResult> Edit(CategoryEditModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
await _commands.Send(new CreateCategoryCommand { Id = model.Id, Name = model.Name });
return(RedirectToAction("Index", new { id = model.Id }));
}
public async Task <IActionResult> Put(string id, CategoryEditModel model)
{
if (!this.ModelState.IsValid)
{
return(this.BadRequest());
}
await this.categoryService.Update(id, model);
return(this.Ok());
}
public async Task<IActionResult> Edit(CategoryEditModel model)
{
var request = new UpdateCatRequest
{
RouteName = model.RouteName,
Note = model.Note,
DisplayName = model.DisplayName
};
await _catService.UpdateAsync(model.Id, request);
return Ok(model);
}
public ActionResult Create(CategoryEditModel model)
{
this.CheckPrices(model.MinPrice, model.MaxPrice);
if (!this.ModelState.IsValid)
{
return this.View(model);
}
this.categoriesService.Create(model.Name, model.MinPrice, model.MaxPrice);
this.TempData["Success"] = "Category added";
return this.RedirectToAction("Index");
}
public ActionResult Edit(CategoryEditModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
model.Category.Updated = DateTime.Now;
model.Category.ByUser = User.Identity.Name;
_service.Update(model.Category);
return(RedirectToAction("Index"));
}
public async Task Edit_ValidModel()
{
var categoryController = CreateCategoryController();
var model = new CategoryEditModel
{
DisplayName = "996",
RouteName = "996",
Note = "fubao"
};
var result = await categoryController.Edit(model);
Assert.IsInstanceOf <OkObjectResult>(result);
}
public void Category_CategoryEdit_ReturnsCategoryServiceUpdate()
{
var viewModel = new CategoryEditModel
{
Category = new CategoryDto()
{
Name = "Test"
}
};
var result = _controller.Edit(viewModel) as RedirectToRouteResult;
_service.Received().Update(viewModel.Category);
}
public void Category_CategoryEdit_ReturnsCategoryIndexView()
{
var viewModel = new CategoryEditModel
{
Category = new CategoryDto()
{
Name = "Test"
}
};
var result = _controller.Edit(viewModel) as RedirectToRouteResult;
Assert.That(result.RouteValues["Action"], Is.EqualTo("Index"));
}
public async Task<IActionResult> Edit(Guid id)
{
var cat = await _catService.Get(id);
if (null == cat) return NotFound();
var model = new CategoryEditModel
{
Id = cat.Id,
DisplayName = cat.DisplayName,
RouteName = cat.RouteName,
Note = cat.Note
};
return Ok(model);
}
private async Task <IActionResult> SaveAsync(CategoryEditModel categoryEditModel, string sender)
{
var returnValue = await _categoryService.Save(categoryEditModel);
if (!returnValue.IsError)
{
TempData[MessageConstants.SuccessMessage] = returnValue.Message;
return(RedirectToAction(nameof(CategoryController.Index)));
}
else
{
TempData[MessageConstants.DangerMessage] = returnValue.Message;
return(RedirectToAction(sender));
}
}
public async Task Create_BadModelState()
{
var categoryController = CreateCategoryController();
var model = new CategoryEditModel
{
DisplayName = "996",
Note = string.Empty
};
categoryController.ModelState.AddModelError("Note", "Note is required");
var result = await categoryController.Create(model);
Assert.IsInstanceOf <BadRequestObjectResult>(result);
}
public Task PrepareCategoryAsync(Category category, CategoryEditModel model)
{
if (category == null)
{
throw new ArgumentNullException(nameof(category));
}
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
category = _mapper.Map(model, category);
return(Task.CompletedTask);
}
public ActionResult Edit(CategoryEditModel model)
{
if (this.ModelState.IsValid)
{
var categoryName = this.categories
.GetAll()
.FirstOrDefault(x => x.Name.ToLower() == model.Name.ToLower());
if (categoryName == null)
{
var category = this.Mapper.Map<Category>(model);
this.categories.Update(model.Id, category);
TempData["Success"] = GlobalConstants.CategoryUpdateNotify;
}
else
{
TempData["Warning"] = GlobalConstants.CategoryExistsNotify;
}
return this.Redirect("/Admin/Categories/Index");
}
return this.View(model);
}
public ActionResult Edit(CategoryEditModel model)
{
this.CheckPrices(model.MinPrice, model.MaxPrice);
if (!this.ModelState.IsValid)
{
this.TempData["Error"] = "Wrong data";
return this.View(model);
}
try
{
this.categoriesService.UpdateById(model.Id, model.Name, model.MinPrice, model.MaxPrice);
}
catch (Exception ex)
{
this.TempData["Error"] = ex.Message;
return this.View(model);
}
this.TempData["Success"] = "Category updated";
return this.RedirectToAction("Index");
}
