public async Task <IActionResult> Detail(int?id)
{
if (id == null)
{
return(NotFound());
}
Course course = await _db.Courses.FindAsync(id);
CourseContent courseContent = await _db.CourseContents.FirstOrDefaultAsync(c => c.Id == course.CourseContentId);
CourseFeature courseFeature = await _db.CourseFeatures.FirstOrDefaultAsync(c => c.Id == course.CourseFeatureId);
CourseVM courseVM = new CourseVM()
{
Course = course,
CourseContent = courseContent,
CourseFeature = courseFeature
};
if (courseVM == null)
{
return(NotFound());
}
return(View(courseVM));
}
public IActionResult Edit(CourseVM course)
{
if (ModelState.IsValid)
{
var teacherF = _teacherService.FindTeacher(course.TeacherId);//använda hitta teacher
var courseToUpdate = new Course
{
Title = course.Title,
Description = course.Description,
Teacher = teacherF,
CourseId = course.CourseId
};
_courseService.UpdateCourse(courseToUpdate);
return(RedirectToAction(nameof(Index)));
}
CourseViewModel CourseViewModel = new CourseViewModel();
//CourseViewModel.course = new Course();
//CourseViewModel.teachers = _teacherService.AllTeacher();//för att byta id tx
//CourseViewModel.students = _studentService.AllStudents();
return(View(course));
}
public async Task <IActionResult> Edit(int?id, CourseVM courseEdit)
{
Course course = await _db.Courses.FindAsync(id);
CourseContent courseContent = await _db.CourseContents.FirstOrDefaultAsync(c => c.Id == course.CourseContentId);
CourseFeature courseFeature = await _db.CourseFeatures.FirstOrDefaultAsync(c => c.Id == course.CourseFeatureId);
CourseVM courseVM = new CourseVM()
{
Course = course,
CourseContent = courseContent,
CourseFeature = courseFeature
};
if (courseEdit == null)
{
return(NotFound());
}
if (id == null)
{
return(NotFound());
}
if (courseEdit.Course.CoursePhoto != null)
{
if (!courseEdit.Course.CoursePhoto.IsImage())
{
ModelState.AddModelError("Photo", "Zehmet olmasa şəkil formati seçin !");
return(View());
}
if (courseEdit.Course.CoursePhoto.MaxLenght(500))
{
ModelState.AddModelError("Photo", "Secilen şəkil olcusu maksimum 500kb olmalidi seçin !");
return(View());
}
PhotoFileDelete.IsDeletePhoto(_env.WebRootPath, "img/course", courseVM.Course.Image);
courseVM.Course.Image = await courseEdit.Course.CoursePhoto.SaveImage(_env.WebRootPath, "img/course");
}
//if (!ModelState.IsValid)
//{
// return View();
//}
courseVM.Course.Title = courseEdit.Course.Title;
courseVM.Course.Description = courseEdit.Course.Description;
courseVM.CourseFeature.Starts = courseEdit.CourseFeature.Starts;
courseVM.CourseFeature.Duration = courseEdit.CourseFeature.Duration;
courseVM.CourseFeature.Class_Duration = courseEdit.CourseFeature.Class_Duration;
courseVM.CourseFeature.Skill_Level = courseEdit.CourseFeature.Skill_Level;
courseVM.CourseFeature.Language = courseEdit.CourseFeature.Language;
courseVM.CourseFeature.Students = courseEdit.CourseFeature.Students;
courseVM.CourseFeature.Assesments = courseEdit.CourseFeature.Assesments;
courseVM.CourseFeature.Course_Fee = courseEdit.CourseFeature.Course_Fee;
courseVM.CourseContent.AboutCourse = courseEdit.CourseContent.AboutCourse;
courseVM.CourseContent.HowToApply = courseEdit.CourseContent.HowToApply;
courseVM.CourseContent.Certification = courseEdit.CourseContent.Certification;
await _db.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
public async Task <IActionResult> DeletePost(int?id)
{
if (id == null)
{
return(NotFound());
}
Course course = await _db.Courses.FindAsync(id);
CourseContent courseContent = await _db.CourseContents.FirstOrDefaultAsync(c => c.Id == course.CourseContentId);
CourseFeature courseFeature = await _db.CourseFeatures.FirstOrDefaultAsync(c => c.Id == course.CourseFeatureId);
CourseVM courseVM = new CourseVM()
{
Course = course,
CourseContent = courseContent,
CourseFeature = courseFeature
};
if (courseVM == null)
{
return(NotFound());
}
PhotoFileDelete.IsDeletePhoto(_env.WebRootPath, "img/course", courseVM.Course.Image);
_db.CourseContents.Remove(courseVM.CourseContent);
_db.CourseFeatures.Remove(courseVM.CourseFeature);
_db.Courses.Remove(courseVM.Course);
await _db.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
//getting courses
public List <CourseVM> getAllCourses()
{
List <CourseVM> courses = new List <CourseVM>();
List <course> coursesFromDB = MCDB.courses.ToList();
foreach (var item in coursesFromDB)
{
CourseVM course = new CourseVM();
course.courses_category = item.courses_category;
course.course_id = item.course_id;
course.instructor_id = item.instructor_id;
course.instructor = item.instructor;
course.course_name = item.course_name;
course.description = item.description;
course.appointments = item.appointments;
course.hours_number = item.hours_number;
course.price = item.price;
course.service_id = item.service_id;
course.service = item.service;
course.isActive = item.isActive;
course.starting_date = item.starting_date;
courses.Add(course);
}
return(courses);
}
public CourseVM getCourseById(int id)
{
course courseToGet = MCDB.courses.Where(x => x.course_id == id).FirstOrDefault();
CourseVM courseVM = new CourseVM();
if (courseToGet != null)
{
courseVM.course_id = courseToGet.course_id;
courseVM.category_id = courseToGet.category_id;
courseVM.courses_category = courseToGet.courses_category;
courseVM.appointments = courseToGet.appointments;
courseVM.course_name = courseToGet.course_name;
courseVM.description = courseToGet.description;
courseVM.hours_number = courseToGet.hours_number;
courseVM.instructor_id = courseToGet.instructor_id;
courseVM.isActive = courseToGet.isActive;
courseVM.price = courseToGet.price;
courseVM.service_id = courseToGet.service_id;
courseVM.starting_date = courseToGet.starting_date;
return(courseVM);
}
else
{
return(null);
}
}
public List <CourseVM> GetAllCourseView()
{
Query = "SELECT dt.Id, ct.CourseCode, ct.CourseName, st.SemesterName, tet.TeacherName, ast.Status FROM Department_tb as dt " +
"INNER JOIN Course_tb as ct on dt.Id = ct.DeptId INNER JOIN Semester_tb as st on ct.SemesterId = st.Id LEFT JOIN " +
"AssignTeacher_tb as ast on ct.Id = ast.CourseId LEFT JOIN Teacher_tb as tet on ast.TeacherId = tet.Id";
Command = new SqlCommand(Query, Connection);
Connection.Open();
Reader = Command.ExecuteReader();
List <CourseVM> courseVms = new List <CourseVM>();
while (Reader.Read())
{
CourseVM aCourseVm = new CourseVM()
{
DeptId = Convert.ToInt32(Reader["Id"]),
CourseCode = Convert.ToString(Reader["CourseCode"]),
CourseName = Convert.ToString(Reader["CourseName"]),
SemesterName = Convert.ToString(Reader["SemesterName"]),
TeacherName = Convert.ToString(Reader["TeacherName"]),
Status = Convert.ToString(Reader["Status"])
};
courseVms.Add(aCourseVm);
}
Connection.Close();
Reader.Close();
return(courseVms);
}
//get courses by category id
public List <CourseVM> GetCoursesByCategId(int id)
{
List <CourseVM> coursesByCategId = new List <CourseVM>();
var coursesToGet = MCDB.courses.Where(x => x.category_id == id).ToList();
foreach (var item in coursesToGet)
{
CourseVM activeCourse = new CourseVM();
activeCourse.appointments = item.appointments;
activeCourse.category_id = item.category_id;
activeCourse.course_id = item.course_id;
activeCourse.course_name = item.course_name;
activeCourse.description = item.description;
activeCourse.hours_number = item.hours_number;
activeCourse.instructor_id = item.instructor_id;
activeCourse.isActive = item.isActive;
activeCourse.price = item.price;
activeCourse.service_id = item.service_id;
activeCourse.starting_date = item.starting_date;
coursesByCategId.Add(activeCourse);
}
return(coursesByCategId);
}
public bool AddCourseToUserProgress(CourseVM courseVM)
{
var mappedCourse = mapper.Map <CourseVM, Course>(courseVM);
if (mappedCourse == null)
{
Dye.Fail();
Console.WriteLine("Unknown course Id");
Console.ResetColor();
return(false);
}
if (userService.AddCourseToProgress(mappedCourse))
{
Dye.Succsess();
Console.WriteLine("Course passing started!");
Console.ResetColor();
return(true);
}
else
{
Dye.Inform();
Console.WriteLine("You have passed this course early");
Console.ResetColor();
return(false);
}
}
public async Task <IActionResult> EditCourse(int?id)
{
if (id == null)
{
return(NotFound());
}
Category category = await _db.Categories.FindAsync(id);
if (category == null)
{
return(NotFound());
}
if (category.isDeleted == true)
{
return(NotFound());
}
CourseVM courseVM = new CourseVM
{
Courses = _db.Courses.Where(c => c.CategoryId == category.Id && c.isDeleted == false),
Category = category
};
return(View(courseVM));
}
public ActionResult Create(CourseVM model)
{
if (ModelState.IsValid)
{
//String sql = "Insert into Courses (CourseName, CourseCode, CreditHour) values ('" + course.CourseName + "', '" + course.CourseCode + "', '" + course.CreditHour + "')";
//db.Create(sql);
db.Courses.Add(model.Course);
var facSemCouObj = new FacultySemesterCourse();
facSemCouObj = new FacultySemesterCourse()
{
FacultyID = model.FacultyID,
SemesterID = model.SemesterID,
CourseID = model.Course.CourseID
};
db.FacultySemesterCourses.Add(facSemCouObj);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(model.Course));
}
public async Task <CourseNotification> Update(CourseVM courseVM)
{
return(await _mediator.Send(new CourseUpdateCommand()
{
course = _mapper.Map <CourseModel>(courseVM)
}));
}
// GET: Course/Edit/5
public ActionResult Edit(int?id)
{
if (id != null)
{
Course course = db.Course.FirstOrDefault(p => p.id == id);
if (course != null)
{
CourseVM model = new CourseVM()
{
Course = course,
Courses = db.Course.ToList(),
Action = "Edit",
Header = "Edit Course"
};
return(View("Index", model));
}
else
{
return(HttpNotFound());
}
}
else
{
return(RedirectToAction("Index"));
}
}
public IActionResult Create()
{
CourseVM model = new CourseVM();
model.Course = new Course();
return(View(model));
}
public void Store(CourseVM courseVM)
{
// VALIDATE IF ALREADY EXITS THIS COURSE
var existingCourse = _courseRepository.GetCourse(courseVM.Name);
if (existingCourse != null)
{
throw new ArgumentException("Course already exists");
}
// VALIDATE TARGET AUDIENCE
if (!Enum.TryParse <TargetAudience>(courseVM.TargetAudience, out var targetAudicence))
{
throw new ArgumentException("Invalid Target Audience");
}
// PREPARE DATA
var course = new Data.Course(courseVM.Name,
courseVM.Description,
courseVM.Workload,
targetAudicence,
courseVM.Value);
// RESULT
_courseRepository.Store(course);
}
public async Task <IActionResult> CreateCourse([FromBody] CourseVM courseVM)
{
var userId = userManager.GetUserId(User);
var department = this.departmentRepository.GetAll().Where(d => d.AccountId == userId).FirstOrDefault();
if (department == null)
{
await signInManager.SignOutAsync();
return(RedirectToPage("Login"));
}
try
{
var course = new Course();
course.Code = courseVM.Code;
course.Title = courseVM.Title;
course.Description = courseVM.Description;
course.Credits = courseVM.Credits;
course.DepartmentId = department.Id;
course.Department = department;
this.courseRepository.Insert(course);
await this.courseRepository.SaveChangeAsync();
return(Ok());
}
catch (Exception)
{
return(BadRequest());
}
}
public IActionResult Edit(int id, CourseVM model)
{
if (id != model.Course.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
//update the course info objects list from the model.Info
Course crs = model.Course;
//replace the string for Bullets with proper Html
crs.Bullets = DecodeBullets(model.Info);
_repository.UpdateCourse(crs);
}
catch (DbUpdateConcurrencyException)
{
if (!_repository.CourseExists(model.Course.Id))
{
return(NotFound());
}
else
{
throw;
}
}
model.ShowSuccessToast = true;
return(View(model));
}
return(View(model));
}
public IActionResult Index()
{
var courses = new CourseVM();
ViewBag.IsSuccess = TempData["IsSuccess"];
return(View(courses));
}
public IActionResult Create(int ID)
{
var vm = new CourseVM();
var lstParent = _courseCategoryService.GetParentCategory();
if (ID != 0)
{
var modelcourse = _courseService.GetById(ID);
if (modelcourse == null)
{
return(NotFound());
}
vm = _mapper.Map <CourseVM>(modelcourse);
var child = _courseCategoryService.GetById(vm.CategoryId);
var selectValueParent = _courseCategoryService.GetById(int.Parse(child.ParentId.ToString()));
var lstChild = _courseCategoryService.GetChildCategory(child.ParentId);
vm.lstCategories = new SelectList(lstParent, "Id", "Name", selectValueParent);
vm.lstChildCategories = new SelectList(lstChild, "Id", "Name", child);
}
else
{
vm.lstCategories = new SelectList(lstParent, "Id", "Name");
vm.lstChildCategories = null;
}
return(View(vm));
}
public IActionResult search_home(string search)
{
var context = _courseService.GetContext();
var d = from c in context.Courses
join u in context.Users
on c.UserId equals u.Id
join cate in context.CourseCategories
on c.CategoryId equals cate.Id
where c.Name.Contains(search)
select new CourseVM
{
Id = c.Id,
Name = c.Name,
FullName = u.FullName,
UserId = u.Id,
PromotionPrice = c.PromotionPrice ?? 0,
Price = c.Price,
Content = c.Content,
Image = c.Image,
Description = c.Description,
CategoryId = c.CategoryId ?? 0
};
var courseVM = new CourseVM();
courseVM.lstCourse = d.ToList();
courseVM.CategoryId = courseVM.lstCourse[0].CategoryId;
return(View("CategoryToCourse", courseVM));
}
public ActionResult EditCourse(CourseVM cvm, FormCollection collection)
{
if (!string.IsNullOrEmpty(collection["activeState"]))
{
string checkResp = collection["activeState"];
bool checkRespB = Convert.ToBoolean(checkResp);
if (checkRespB)
{
cvm.isActive = true;
}
else
{
cvm.isActive = false;
}
}
else
{
cvm.isActive = false;
}
courseBll.UpdateCourse(cvm);
List <CourseVM> courses = courseBll.getAllCourses();
ViewBag.courses = courses;
return(RedirectToAction("getAllCourses", "Course", new { area = "AdminArea" }));
}
//GET: Admin/Shop/DeleteCourse/id
public ActionResult DeleteCourse(int id)
{
CourseVM model;
using (Db db = new Db()) {
CourseDTO dto = db.Courses.Find(id);
model = new CourseVM(dto);
db.Courses.Remove(dto);
db.SaveChanges();
}
DirectoryInfo originalDirectory =
new DirectoryInfo(string.Format("{0}Courses\\",
Server.MapPath(@"\")));
string pathString1 = Path
.Combine(originalDirectory.ToString()
+ model.Name);
string path = string
.Format("{0}\\{1}", pathString1, model.VideoName);
string pathString3 = Path
.Combine(originalDirectory.ToString() +
model.Name + "\\Chapters");
if (Directory.Exists(pathString1))
{
Directory.Delete(pathString1, true);
}
return(RedirectToAction("Courses"));
}
public async Task <IActionResult> Details(int?id)
{
if (id == null)
{
return(NotFound());
}
Course course = await _context.Courses.Where(c => !c.IsDeleted && c.Activeted && c.Id == id).FirstOrDefaultAsync();
if (course == null)
{
return(NotFound());
}
_context.IncludeCategory(true);
List <Course> lastestCourse = _context.Courses.Where(c => !c.IsDeleted && c.Activeted).OrderByDescending(c => c.Created_at).Take(3).ToList();
_context.IncludeModerators(true);
List <Tag> tags = _context.GetTags();
CourseVM courseVM = new CourseVM()
{
Course = course,
LastestCourse = lastestCourse,
Tags = tags
};
return(View(courseVM));
}
public ActionResult UpdateCourse(string option, CourseVM course, int id)
{
course.ID = id;
if (option == "Checked")
{
if (ModelState.IsValid == true)
{
string filename = Path.GetFileName(course.ImageFile.FileName);
course.image = filename;
filename = Path.Combine(Server.MapPath("~/Content/") + filename);
course.ImageFile.SaveAs(filename);
courseAppService.UpdateCourse(course);
return(RedirectToAction("Index"));
}
}
else
{
if (ModelState.IsValid == true)
{
courseAppService.UpdateCourse(course);
return(RedirectToAction("Index"));
}
}
return(View(course));
}
public IActionResult Filter(string search)
{
if (search == null)
{
return(RedirectToAction("Index"));
}
IEnumerable <Course> courses;
bool check = _db.Courses.Any(c => c.Name.Contains(search));
if (check)
{
courses = _db.Courses.Where(c => c.Name.Contains(search)).Include(c => c.CourseDetail).Take(9);
}
else
{
courses = null;
}
CourseVM model = new CourseVM()
{
Background = _db.Backgrounds.FirstOrDefault(),
Course = courses
};
return(View(model));
}
public XElement Offers()
{
_courseSections = GetCourseSections();
var courseDescs = GetCourseDescs();
var courses = GetCourses();
return(X("offers",
courses.Select(x => {
var priceName = "(Очно)";
var price = x.Prices.FirstOrDefault(z =>
z.PriceType_TC == PriceTypes.PrivatePersonWeekend);
if (price == null)
{
priceName = "(Дистанционно)";
}
return GetOffer((int)x.Course.Course_ID,
x.Course.IsTrackBool
? _url.Action <TrackController>(c => c.Details(x.Course.UrlName))
: _url.Action <CourseController>(c => c.Details(x.Course.UrlName)),
(int)(price != null
? price.Price : x.Prices.Select(y => y.Price).Min()),
GetCategoryId(x.Course),
CourseVM.WithCoursePrefix(x.Course.GetName()) + " " + priceName,
StringUtils.RemoveTags(courseDescs
.GetValueOrDefault(x.Course.Course_TC)) +
(price != null ? "" : " Дистанционный курс."));
}),
_exams.Select(s => GetOffer(VendorOffset + (int)s.Exam_ID,
_url.Action <ExamController>(c => c.Details(s.Exam_TC.Trim())),
(int)s.ExamPrice, VendorOffset + s.Vendor_ID,
"Экзамен " + s.ExamName, "Языки: " + s.Languages + ". Продолжительность: " +
s.Minutes + " мин.", GetProviderPicture(s.ExamType)))
));
}
// GET: Courses/Create
public ActionResult Create()
{
var courseVM = new CourseVM();
courseVM.TeacherIdSelectList = SelectListHelper.CreateSelectListProp(SelectListHelper.PopulateTeacherSelectList());
return(View(courseVM));
}
public async Task <IActionResult> List(int id)
{
CourseVM courseViewModel = new CourseVM();
courseViewModel.SillabusList = await _dbContext.Sillabus.Include(x => x.Course).Where(x => x.CourseId == id).ToListAsync();
return(View(courseViewModel));
}
public async Task <IActionResult> OwnDidactic(int id)
{
CourseVM courseViewModel = new CourseVM();
ViewBag.CourseId = id;
courseViewModel.DidacticMaterials = await _dbContext.DidacticMaterials.Include(x => x.Course).Where(x => x.CourseId == id).ToListAsync();
return(View(courseViewModel));
}
//[Authorize]
public async Task <IActionResult> Create()
{
CourseVM courseVM = new CourseVM
{
Categories = await _dbContext.Categories.ToListAsync()
};
return(View(courseVM));
}
