public HttpResponseMessage Update(HttpRequestMessage request, CourseCategoryViewModel category)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
if (!ModelState.IsValid)
{
response = request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState);
}
else
{
var categoryDb = _courseCategoryService.GetCategory(category.ID);
if (categoryDb == null)
{
response = request.CreateErrorResponse(HttpStatusCode.NotFound, "Invalid.");
}
else
{
categoryDb.UpdateCourseCategory(category);
_courseCategoryService.SaveCategory();
response = request.CreateResponse(HttpStatusCode.OK, category);
}
}
return response;
}));
}
public ActionResult Create()
{
var viewModel = new CourseCategoryViewModel();
viewModel.Categories = _context.Categories.ToList();
return(View(viewModel));
}
public HttpResponseMessage Update(HttpRequestMessage request, CourseCategoryViewModel courseCategoryViewModel)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
if (!ModelState.IsValid)
{
response = request.CreateResponse(HttpStatusCode.BadRequest, ModelState);
}
else
{
//var dbCourseCategory = new CourseCategory();
var dbCourseCategory = _courseCategoryService.GetById(courseCategoryViewModel.Cate_ID);
dbCourseCategory.UpdateCourseCategory(courseCategoryViewModel);
dbCourseCategory.UpdatedDate = DateTime.Now;
_courseCategoryService.Update(dbCourseCategory);
_courseCategoryService.Save();
var responseData = Mapper.Map <CourseCategory, CourseCategoryViewModel>(dbCourseCategory);
response = request.CreateResponse(HttpStatusCode.Created, responseData);
}
return response;
}));
}
public ActionResult Create(CourseCategoryViewModel coursecate)
{
if (ModelState.IsValid)
{
var check = _context.Courses.Include(c => c.Category)
.Where(c => c.Name == coursecate.Course.Name && c.CategoryID == coursecate.Course.CategoryID);
//GET NameCOurse and Category ID from VM
if (check.Count() > 0) //list ID comparison, if count == 0. jump to else
{
ModelState.AddModelError("", "Course Already Exists.");
}
else
{
_context.Courses.Add(coursecate.Course);
_context.SaveChanges();
return(RedirectToAction("Index"));
}
}
var courseVM = new CourseCategoryViewModel()
{
Categories = _context.Categories.ToList(),
Course = coursecate.Course,
};
return(View(courseVM));
}
public ActionResult Edit(CourseCategoryViewModel edit)
{
if (ModelState.IsValid)
{
var check = _context.Courses.Include(c => c.Category).Where(c => c.Name == edit.Course.Name && c.CategoryID == edit.Course.CategoryID);
if (check.Count() > 0)
{
ModelState.AddModelError("", "Course Already Exists.");
}
else
{
var courseInDb = _context.Courses.Find(edit.Course.ID);
courseInDb.Name = edit.Course.Name;
courseInDb.Description = edit.Course.Description;
_context.SaveChanges();
return(RedirectToAction("Index"));
}
}
var courseVM = new CourseCategoryViewModel()
{
Categories = _context.Categories.ToList(),
Course = edit.Course,
};
return(View(courseVM));
}
// GET: Courses
public async Task <IActionResult> Index(string courseCategory, string searchString)
{
IQueryable <string> categoryQuery = from m in _context.Courses
orderby m.Category
select m.Category;
var courses = from m in _context.Courses
select m;
if (!String.IsNullOrEmpty(searchString))
{
courses = courses.Where(s => s.Category.Contains(searchString));
}
if (!String.IsNullOrEmpty(courseCategory))
{
courses = courses.Where(x => x.Category == courseCategory);
}
var courseCategoryVM = new CourseCategoryViewModel();
courseCategoryVM.categories = new SelectList(await categoryQuery.Distinct().ToListAsync());
courseCategoryVM.course = await courses.ToListAsync();
return(View(courseCategoryVM));
}
public HttpResponseMessage Add(HttpRequestMessage request, CourseCategoryViewModel category)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
if (!ModelState.IsValid)
{
response = request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState);
}
else
{
var newCategory = new CourseCategory();
newCategory.UpdateCourseCategory(category);
_courseCategoryService.CreateCategory(newCategory);
_courseCategoryService.SaveCategory();
// Update view model
category = Mapper.Map <CourseCategory, CourseCategoryViewModel>(newCategory);
response = request.CreateResponse(HttpStatusCode.Created, category);
}
return response;
}));
}
public ActionResult CreateCourse()
{
var courseCategory = new CourseCategoryViewModel()
{
Categories = _context.Categories.ToList(),
};
return(View(courseCategory));
}
public static void UpdateCourseCategory(this CourseCategory category, CourseCategoryViewModel categoryVm)
{
category.Name = categoryVm.Name;
category.Alias = string.IsNullOrEmpty(categoryVm.Alias) ? StringHelper.ToUnsignString(categoryVm.Name) : categoryVm.Alias;
category.DisplayOrder = categoryVm.DisplayOrder;
category.Status = categoryVm.Status;
category.MetaKeyword = categoryVm.MetaKeyword;
category.MetaDescription = categoryVm.MetaDescription;
category.ShowHome = categoryVm.ShowHome;
}
public ActionResult Index(string SearchTerm)
{
CourseCategoryViewModel model = new CourseCategoryViewModel
{
All = service.Search(SearchTerm),
SearchTerm = SearchTerm
};
return(View(model));
}
public ActionResult CreateCourse(CourseCategoryViewModel courseCategoryViewModel)
{
var new_course = new Course()
{
Name = courseCategoryViewModel.Course.Name,
Category_Id = courseCategoryViewModel.CategoryId
};
_context.Courses.Add(new_course);
_context.SaveChanges();
return(RedirectToAction("CourseManagement"));
}
public static void UpdateCourseCategory(this CourseCategory courseCategory, CourseCategoryViewModel courseCategoryViewModel)
{
courseCategory.Cate_Alias = courseCategoryViewModel.Cate_Alias;
courseCategory.Cate_Description = courseCategoryViewModel.Cate_Description;
courseCategory.Cate_ID = courseCategoryViewModel.Cate_ID;
courseCategory.Cate_Image = courseCategoryViewModel.Cate_Image;
courseCategory.Cate_Name = courseCategoryViewModel.Cate_Name;
courseCategory.CreatedBy = courseCategoryViewModel.CreatedBy;
courseCategory.CreatedDate = courseCategoryViewModel.CreatedDate;
courseCategory.MetaDescription = courseCategory.MetaDescription;
courseCategory.Status = courseCategoryViewModel.Status;
courseCategory.UpdatedBy = courseCategoryViewModel.UpdatedBy;
courseCategory.UpdatedDate = courseCategoryViewModel.UpdatedDate;
courseCategory.MetaKeyword = courseCategoryViewModel.MetaKeyword;
}
public ActionResult Edit(int id)
{
var courseInDb = _context.Courses.SingleOrDefault(c => c.Id == id);
if (courseInDb == null)
{
return(HttpNotFound());
}
var viewModel = new CourseCategoryViewModel
{
Course = courseInDb,
Categories = _context.Categories.ToList()
};
return(View(viewModel));
}
public ActionResult <Course> Create(string id, Course course)
{
CourseCategoryViewModel viewModel = new CourseCategoryViewModel
{
School = _schoolService.Get(id),
SchoolArray = _schoolService.Get().ToList(),
Course = _courseService.Create(course),
CategoryArray = _categoryService.Get().ToList(),
Category = _categoryService.Get(id)
};
//_courseService.Create(course);
return(CreatedAtRoute("GetCourse", new { id = course.Id.ToString() }, course));
//return View(viewModel);
}
public ActionResult Edit(int id)
{
var CourseInDb = _context.Courses.SingleOrDefault(m => m.Id == id);
if (CourseInDb == null)
{
return(HttpNotFound());
}
var viewModel = new CourseCategoryViewModel()
{
Categories = _context.Categories.ToList(),
Course = CourseInDb
};
return(View(viewModel));
}
public ActionResult CreateCourse(CourseCategoryViewModel newcourseCatViewModel)
{
if (ModelState.IsValid)
{
bool isSuccess = false;
try
{
var isRecordAlreadyExist = _dbcontext.CourseCategories.Any(x => x.Course.ToLower().Contains(newcourseCatViewModel.Coursename.ToLower()));
if (isRecordAlreadyExist)
{
// ModelState.AddModelError("Course", newcourseCatViewModel.Coursename + " already exist!.");
return(Json(
new { success = isSuccess, message = "Unable to save record ;\n Possible for duplicate entry." }, JsonRequestBehavior.AllowGet));
}
else
{
var coursecat = new CourseCategory()
{
CourserId = Convert.ToInt32(newcourseCatViewModel.CourserId),
Course = newcourseCatViewModel.Coursename,
Note = newcourseCatViewModel.Note,
Main_Bol = newcourseCatViewModel.Main_Bol
};
_dbcontext.CourseCategories.Add(coursecat);
_dbcontext.SaveChanges();
isSuccess = true;
//return RedirectToAction("Index", "Course");
return(Json(new { success = isSuccess }, JsonRequestBehavior.AllowGet));
}
}
catch (Exception)
{
throw new HttpException(404, "Page Not Found");
}
}
ViewBag.FormTitle = "New Course Category";
return(View(newcourseCatViewModel));
}
public static void UpdateCourseCategory(this CourseCategory courseCategory, CourseCategoryViewModel courseCategoryVm)
{
courseCategory.ID = courseCategoryVm.ID;
courseCategory.Name = courseCategoryVm.Name;
courseCategory.Description = courseCategoryVm.Description;
courseCategory.Alias = courseCategoryVm.Alias;
courseCategory.ParentID = courseCategoryVm.ParentID;
courseCategory.DisplayOrder = courseCategoryVm.DisplayOrder;
courseCategory.CreatedDate = courseCategoryVm.CreatedDate;
courseCategory.CreatedBy = courseCategoryVm.CreatedBy;
courseCategory.UpdatedDate = courseCategoryVm.UpdatedDate;
courseCategory.UpdatedBy = courseCategoryVm.UpdatedBy;
courseCategory.Status = courseCategoryVm.Status;
}
public ActionResult ModifyCourse(CourseCategoryViewModel courseviewModel)
{
if (ModelState.IsValid)
{
bool isSuccess = false;
try
{
var modifycourse = _dbcontext.CourseCategories.FirstOrDefault(cc => cc.CourserId == courseviewModel.CourserId);
if (modifycourse != null)
{
modifycourse.CourserId = Convert.ToInt32(courseviewModel.CourserId);
modifycourse.Course = courseviewModel.Coursename;
modifycourse.Note = courseviewModel.Note;
modifycourse.Main_Bol = courseviewModel.Main_Bol;
}
_dbcontext.SaveChanges();
isSuccess = true;
//return RedirectToAction("Index", "Course");
return(Json(new { success = isSuccess }, JsonRequestBehavior.AllowGet));
}
catch (Exception)
{
throw new HttpException(404, "Page Not Found");
}
}
ViewBag.FormTitle = "Modify Course Category";
return(View(courseviewModel));
}
public HttpResponseMessage Create(HttpRequestMessage request, CourseCategoryViewModel courseCategoryVM)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
if (!ModelState.IsValid)
{
response = request.CreateResponse(HttpStatusCode.BadRequest, ModelState);
}
else
{
var newCourseCategory = new CourseCategory();
newCourseCategory.UpdateCourseCategory(courseCategoryVM);
_courseCategoryService.Add(newCourseCategory);
_courseCategoryService.Save();
var responseData = Mapper.Map <CourseCategory, CourseCategoryViewModel>(newCourseCategory);
response = request.CreateResponse(HttpStatusCode.Created, responseData);
}
return response;
}));
}
