public async Task <IActionResult> Create(CategoryAndSubCategoryViewModel model)
{
if (ModelState.IsValid)
{
var doesSubExists = _db.SubCategories.Include(c => c.CategoryVP).Where(s => s.Name == model.SubCategoryVM.Name &&
s.CategoryVP.Id == model.SubCategoryVM.CategoryId);
if (doesSubExists.Count() > 0)
{
StatusMessage = $"Error! Subkategoria {doesSubExists.First().Name} in {doesSubExists.First().CategoryVP.Name} ! ";
}
else
{
_db.SubCategories.Add(model.SubCategoryVM);
await _db.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
}
CategoryAndSubCategoryViewModel modelVM = new CategoryAndSubCategoryViewModel()
{
CategoryList = await _db.Categories.ToListAsync(),
SubCategoryVM = model.SubCategoryVM,
SubCategoryListStr = await _db.SubCategories.OrderBy(s => s.Name).Select(s => s.Name).Distinct().ToListAsync(),
StatusMsg = StatusMessage
};
return(View(modelVM));
}
public async Task <IActionResult> Create(CategoryAndSubCategoryViewModel _subcategoryData)
{
var doesExistAlready = _db.SubCategory.Include(s => s.Category)
.Where(s => s.Name == _subcategoryData.SubCategory.Name && s.Category.Id == _subcategoryData.SubCategory.CategoryId);
if (ModelState.IsValid)
{
if (doesExistAlready.Count() > 0)
{
// error
StatusMessage = "Error: This Subcategory is already exist in " + doesExistAlready.First().Category.Name;
}
else
{
await _db.SubCategory.AddAsync(_subcategoryData.SubCategory);
await _db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
}
var errorSubCategory = new CategoryAndSubCategoryViewModel()
{
CategoryList = await _db.Category.ToListAsync()
, SubCategory = _subcategoryData.SubCategory
, SubCategoryList = await _db.SubCategory.OrderBy(p => p.Name).Select(p => p.Name).ToListAsync()
, StatusMessage = StatusMessage
};
return(View(errorSubCategory));
}
public async Task <IActionResult> Create(CategoryAndSubCategoryViewModel model)
{
if (ModelState.IsValid)
{
var DoesExistingEntries = await _db.Subcategory.Include(m => m.Category).Where(m => m.Name == model.Subcategory.Name && m.Category.Id == model.Subcategory.CategoryId).ToListAsync();
if (DoesExistingEntries.Count > 0)
{
StatusMessage = "Error: please use another sub-category name!";
}
else
{
_db.Subcategory.Add(model.Subcategory);
await _db.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
}
CategoryAndSubCategoryViewModel model2 = new CategoryAndSubCategoryViewModel()
{
CategoryList = await _db.Category.ToListAsync(),
Subcategory = new SubCategory(),
SubcategoryList = await _db.Subcategory.OrderBy(m => m.Name).Select(m => m.Name).ToListAsync(),
Message = StatusMessage
};
return(View(model2));
}
public async Task <IActionResult> Create(CategoryAndSubCategoryViewModel model)
{
if (ModelState.IsValid)
{
var isExistCategory = _db.SubCategories.Include(s => s.Category).Where(s => s.Name == model.SubCategory.Name && s.Category.Id == model.SubCategory.CategoryId);
if (isExistCategory.Count() > 0)
{
//Error
AlertMessage = "Error : SubCategory found under " + isExistCategory.First().Category.Name + " category. Please!! Use another Name.";
}
else
{
_db.SubCategories.Add(model.SubCategory);
await _db.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
}
CategoryAndSubCategoryViewModel modelVM = new CategoryAndSubCategoryViewModel()
{
CategoryList = await _db.Categories.ToListAsync(),
SubCategory = model.SubCategory,
SubCategoryList = await _db.SubCategories.OrderBy(p => p.Name).Select(p => p.Name).ToListAsync(),
AlertMessage = AlertMessage
};
return(View(modelVM));
}
public async Task <ActionResult> Create(CategoryAndSubCategoryViewModel model)
{
if (ModelState.IsValid)
{
var subCategory = _db.SubCategory.Include(s => s.Category).Where(s => s.Name == model.SubCategory.Name && s.Category.Id == model.SubCategory.CategoryId);
if (subCategory.Count() > 0)
{
StatusMessage = "Error : SubCategory Already Exists";
}
else
{
_db.SubCategory.Add(model.SubCategory);
await _db.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
}
CategoryAndSubCategoryViewModel modelVm = new CategoryAndSubCategoryViewModel
{
CategoryList = await _db.Category.ToListAsync(),
SubCategory = model.SubCategory,
SubCategoryList = await _db.SubCategory.OrderBy(s => s.Name).Select(s => s.Name).ToListAsync(),
StatusMessage = StatusMessage
};
return(View(modelVm));
}
public async Task <IActionResult> Create(CategoryAndSubCategoryViewModel model)
{
if (ModelState.IsValid)
{
var category = _context.SubCategories.Include(sc => sc.Category).Where(sc => sc.Name == model.SubCategory.Name && sc.Category.Id == model.SubCategory.CategoryId);
if (category.Count() > 0)
{
StatusMessage = $"Error: There's a register called {model.SubCategory.Name} in the Category selected, please select a diferent one.";
}
else
{
_context.SubCategories.Add(model.SubCategory);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
}
return(View(new CategoryAndSubCategoryViewModel()
{
Categories = await _context.Categories.ToListAsync(),
SubCategory = model.SubCategory,
SubCategories = await _context.SubCategories.OrderBy(sc => sc.Name).Select(sc => sc.Name).Distinct().ToListAsync(),
StatusMessage = StatusMessage
}));
}
public async Task <IActionResult> Create(CategoryAndSubCategoryViewModel model)
{
var doesSubCategoryExists = _db.SubCategory.Include(s => s.Category)
.Where(p => p.Name == model.SubCategory.Name && p.Category.Id == model.SubCategory.CategoryId);
if (doesSubCategoryExists.Count() > 0)
{
//Error
StatusMessageSubCategory = "Error:SubCategory Exists Under " +
doesSubCategoryExists.First().Category.Name +
" category.Please use another name";
}
else
{
_db.SubCategory.Add(model.SubCategory);
await _db.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
var modelVM = new CategoryAndSubCategoryViewModel()
{
CategoryList = await _db.Category.ToListAsync(),
SubCategory = new Models.SubCategory(),
SubCategoryList = await _db.SubCategory.OrderBy(p => p.Name).
Select(p => p.Name).ToListAsync(),
StatusMessage = StatusMessageSubCategory
};
return(View(modelVM));
}
public async Task <IActionResult> Create()
{
CategoryAndSubCategoryViewModel model = new CategoryAndSubCategoryViewModel()
{
CategoryList = await _db.Category.ToListAsync(),
Subcategory = new SubCategory(),
SubcategoryList = await _db.Subcategory.OrderBy(m => m.Name).Select(m => m.Name).ToListAsync(),
};
return(View(model));
}
// GET: SubCategory/Create
public async Task <ActionResult> Create()
{
CategoryAndSubCategoryViewModel model = new CategoryAndSubCategoryViewModel
{
CategoryList = await _db.Category.ToListAsync(),
SubCategory = new Models.SubCategory(),
SubCategoryList = await _db.SubCategory.OrderBy(s => s.Name).Select(s => s.Name).ToListAsync()
};
return(View(model));
}
// GET CREATE
public async Task <IActionResult> Create()
{
var model = new CategoryAndSubCategoryViewModel()
{
Categories = await _context.Categories.ToListAsync(),
SubCategories = await _context.SubCategories.OrderBy(sc => sc.Name).Select(sc => sc.Name).Distinct().ToListAsync(),
SubCategory = new SubCategory()
};
return(View(model));
}
//GET - CREATE
public async Task <IActionResult> Create()
{
CategoryAndSubCategoryViewModel model = new CategoryAndSubCategoryViewModel()
{
CategoryList = await _db.Categories.ToListAsync(),
SubCategory = new Models.SubCategory(),
SubCategoryList = await _db.SubCategories.OrderBy(p => p.Name).Select(p => p.Name).Distinct().ToListAsync()
};
return(View(model));
}
public async Task <IActionResult> Delete(int?id)
{
if (id == null)
{
return(NotFound());
}
CategoryAndSubCategoryViewModel deleteItem = new CategoryAndSubCategoryViewModel();
deleteItem.SubCategory = await _db.SubCategory.FindAsync(id);
deleteItem.CategoryList = await _db.Category.ToListAsync();
return(View(deleteItem));
}
public async Task <IActionResult> Create()
{
CategoryAndSubCategoryViewModel categoryAndSubViewModel = new CategoryAndSubCategoryViewModel();
categoryAndSubViewModel.CategoryList = await _db.Category.ToListAsync();
categoryAndSubViewModel.SubCategory = new Models.SubCategory();
categoryAndSubViewModel.SubCategoryList = await _db.SubCategory
.OrderBy(s => s.Name)
.Select(s => s.Name)
.Distinct()
.ToListAsync();
return(View(categoryAndSubViewModel));
}
public async Task <IActionResult> Delete(int?id)
{
if (id == null)
{
return(NotFound());
}
var subcategoryfromdb = await _db.Subcategory.SingleOrDefaultAsync(m => m.Id == id);
CategoryAndSubCategoryViewModel model = new CategoryAndSubCategoryViewModel()
{
CategoryList = await _db.Category.ToListAsync(),
Subcategory = subcategoryfromdb,
SubcategoryList = await _db.Subcategory.OrderBy(m => m.Name).Select(m => m.Name).ToListAsync(),
Message = StatusMessage
};
return(View(model));
}
// GET: SubCategory/Edit/5
public async Task <ActionResult> Edit(int?id)
{
if (id == null)
{
return(NotFound());
}
SubCategory subCategory = await _db.SubCategory.Include(s => s.Category).FirstOrDefaultAsync(s => s.Id == id);
if (subCategory == null)
{
return(NotFound());
}
CategoryAndSubCategoryViewModel model = new CategoryAndSubCategoryViewModel
{
CategoryList = await _db.Category.ToListAsync(),
SubCategory = subCategory,
SubCategoryList = await _db.SubCategory.OrderBy(s => s.Name).Select(s => s.Name).ToListAsync()
};
return(View(model));
}
public async Task <IActionResult> Edit(int?id, CategoryAndSubCategoryViewModel _editData)
{
if (ModelState.IsValid)
{
var isDuplicate = await _db.SubCategory.Include(s => s.Category)
.Where(s => s.Category.Id == _editData.SubCategory.CategoryId && s.Name == _editData.SubCategory.Name)
.ToListAsync();
if (isDuplicate.Count() > 0)
{
StatusMessage = StatusMessage = "Error: This Subcategory is already exist in " + isDuplicate.First().Category.Name;
}
else
{
try
{
var foundData = await _db.SubCategory.FindAsync(id);
foundData.Name = _editData.SubCategory.Name;
await _db.SaveChangesAsync();
return(RedirectToAction("Index"));
} catch (Exception e)
{
Console.WriteLine(e);
return(RedirectToAction("Index"));
}
}
}
var errorSubCategory = new CategoryAndSubCategoryViewModel()
{
CategoryList = await _db.Category.ToListAsync()
, SubCategory = _editData.SubCategory
, SubCategoryList = await _db.SubCategory.OrderBy(p => p.Name).Select(p => p.Name).ToListAsync()
, StatusMessage = StatusMessage
};
return(View(errorSubCategory));
}
public async Task <IActionResult> Edit(int?id)
{
if (id == null)
{
return(NotFound());
}
var editSubcategory = await _db.SubCategory.FindAsync(id);
if (editSubcategory == null)
{
return(NotFound());
}
CategoryAndSubCategoryViewModel subcategoryObj = new CategoryAndSubCategoryViewModel()
{
CategoryList = await _db.Category.ToListAsync()
,
SubCategory = editSubcategory
,
SubCategoryList = await _db.SubCategory.OrderBy(s => s.Name).Select(s => s.Name).ToListAsync()
};
return(View(subcategoryObj));
}
//GET - EDIT
public async Task <IActionResult> Edit(int?id)
{
if (id == null)
{
return(NotFound());
}
var subcategory = await _db.SubCategories.SingleOrDefaultAsync(m => m.Id == id);
if (subcategory == null)
{
return(NotFound());
}
CategoryAndSubCategoryViewModel model = new CategoryAndSubCategoryViewModel()
{
CategoryList = await _db.Categories.ToListAsync(),
SubCategory = subcategory,
SubCategoryList = await _db.SubCategories.OrderBy(p => p.Name).Select(p => p.Name).Distinct().ToListAsync()
};
return(View(model));
}
//Delete Get
public async Task <IActionResult> Delete(int?id)
{
if (id == null)
{
return(NotFound());
}
//var subcategory = await _db.SubCategories.FindAsync(id);
var subcategory = await _db.SubCategories.FirstOrDefaultAsync(s => s.Id == id);
if (subcategory == null)
{
return(NotFound());
}
CategoryAndSubCategoryViewModel modelVM = new CategoryAndSubCategoryViewModel()
{
CategoryList = await _db.Categories.ToListAsync(),
SubCategoryVM = subcategory,
SubCategoryListStr = await _db.SubCategories.OrderBy(s => s.Name).Select(s => s.Name).ToListAsync(),
StatusMsg = StatusMessage
};
return(View(modelVM));
}
