public async Task <IActionResult> Create(CourseUpSertDTO req)
        {
            try
            {
                if (ModelState.IsValid)
                {
                    var imgPath = await Utils.SaveFile(req.Image, "Course");

                    if (_context.Courses.Any(c => c.Code.Equals(req.Code) && c.Deleted != 1))
                    {
                        return(Json(new { status = false, msg = "This course code was exist" }));
                    }

                    var course = new Course
                    {
                        DepartmentID  = req.DepartmentID,
                        ImageURL      = imgPath,
                        Name          = req.Name,
                        StartDate     = req.StartDate,
                        EndDate       = req.EndDate,
                        Info          = req.Info,
                        StudentNumber = req.StudentNumber,
                        Price         = req.Price,
                        Status        = 0,
                        Code          = req.Code,
                        UpdatedAt     = DateTime.Now,
                        CreatedAt     = DateTime.Now
                    };

                    _context.Add(course);
                    await _context.SaveChangesAsync();

                    var subjectList = JsonSerializer.Deserialize <List <CourseSubject> >(req.Subjects);
                    foreach (var s in subjectList)
                    {
                        if (s.SubjectID > 0)
                        {
                            s.CourseID = course.ID;
                        }
                    }

                    await _context.CourseSubjects.AddRangeAsync(subjectList);

                    await _context.SaveChangesAsync();

                    return(Json(new { status = true, msg = MESSAGE_SUCCESS }));
                }

                return(Json(new { status = false, msg = MESSAGE_NOT_CREATE }));
            }
            catch (Exception ex)
            {
                return(Json(new { status = false, msg = ex.Message }));
            }
        }
        public IActionResult Create()
        {
            var res = new CourseUpSertDTO();

            try
            {
                res.DepartmentList = _context.Departments.Where(d => d.Deleted != 1)
                                     .OrderByDescending(d => d.UpdatedAt)
                                     .Select(d => new DepartmentSelectDTO
                {
                    ID   = (int)d.ID,
                    Name = d.Name
                });

                return(View(res));
            }
            catch (Exception ex)
            {
                TempData["Error"] = ex.Message;
                return(View(res));
            }
        }
        public async Task <IActionResult> Edit(int id, CourseUpSertDTO req)
        {
            if (ModelState.IsValid)
            {
                try
                {
                    var imgPath = await Utils.SaveFile(req.Image, "Faculty");

                    var course = await _context.Courses.
                                 FirstOrDefaultAsync(c => c.ID == id && c.Deleted != 1);

                    if (course == null)
                    {
                        TempData["Error"] = "Course not found";
                        return(RedirectToAction(nameof(Index)));
                    }

                    if (course.Status == 1)
                    {
                        TempData["Error"] = "Course can't edit";
                        return(RedirectToAction(nameof(Index)));
                    }

                    course.DepartmentID  = req.DepartmentID;
                    course.ImageURL      = string.IsNullOrEmpty(imgPath) ? course.ImageURL: imgPath;
                    course.Name          = req.Name;
                    course.Info          = req.Info;
                    course.Price         = req.Price;
                    course.EndDate       = req.EndDate;
                    course.StudentNumber = req.StudentNumber;
                    course.StartDate     = req.StartDate;
                    course.UpdatedAt     = DateTime.Now;

                    var courseSubjectList      = new List <CourseSubject>();
                    var courseSubjectExistList = await _context.CourseSubjects
                                                 .Where(cs => cs.CourseID == course.ID).ToListAsync();

                    var courseSubjectIDExistList = courseSubjectExistList.Select(cs => cs.SubjectID).ToList();
                    var subjectList = JsonSerializer.Deserialize <List <CourseSubject> >(req.Subjects);

                    foreach (var s in subjectList)
                    {
                        if (s.SubjectID > 0 && courseSubjectIDExistList.Contains(s.SubjectID))
                        {
                            var subject = courseSubjectExistList
                                          .FirstOrDefault(cs => cs.SubjectID == s.SubjectID);

                            if (subject.FacultyID != s.FacultyID)
                            {
                                subject.FacultyID = s.FacultyID;
                                _context.CourseSubjects.Update(subject);
                            }

                            courseSubjectExistList = courseSubjectExistList
                                                     .Where(cs => cs.SubjectID != s.SubjectID).ToList();
                        }
                        else if (s.SubjectID > 0)
                        {
                            courseSubjectList.Add(new CourseSubject {
                                SubjectID = s.SubjectID,
                                FacultyID = s.FacultyID,
                                CourseID  = course.ID
                            });
                        }
                    }

                    if (courseSubjectExistList.Count > 0)
                    {
                        _context.CourseSubjects.RemoveRange(courseSubjectExistList);
                    }

                    await _context.CourseSubjects.AddRangeAsync(courseSubjectList);

                    _context.Update(course);
                    await _context.SaveChangesAsync();

                    return(Json(new { status = true, msg = MESSAGE_SUCCESS }));
                }
                catch (Exception ex)
                {
                    if (!CourseExists(id))
                    {
                        return(Json(new { status = false, msg = "This course is not exist" }));
                    }
                    else
                    {
                        return(Json(new { status = false, msg = ex.Message }));

                        throw;
                    }
                }
            }

            return(Json(new { status = false, msg = MESSAGE_NOT_UPDATE }));
        }
        public async Task <IActionResult> Edit(int?id)
        {
            try
            {
                if (id == null)
                {
                    TempData["Error"] = "Course not found";
                    return(RedirectToAction(nameof(Index)));
                }

                var course = await _context.Courses
                             .FirstOrDefaultAsync(d => d.ID == id && d.Deleted != 1);

                if (course == null)
                {
                    TempData["Error"] = "Course not found";
                    return(RedirectToAction(nameof(Index)));
                }

                if (course.Status == 1)
                {
                    TempData["Error"] = "Course can't edit";
                    return(RedirectToAction(nameof(Index)));
                }

                var res = new CourseUpSertDTO
                {
                    ID            = course.ID,
                    DepartmentID  = course.DepartmentID,
                    ImageURL      = course.ImageURL,
                    Info          = course.Info,
                    StudentNumber = course.StudentNumber,
                    Name          = course.Name,
                    Price         = course.Price,
                    Code          = course.Code,
                    EndDate       = course.EndDate,
                    StartDate     = course.StartDate,
                };

                res.SubjectList = from cs in _context.CourseSubjects
                                  join s in _context.Subjects on cs.SubjectID equals s.ID
                                  into s
                                  from ms in s.DefaultIfEmpty()
                                  join f in _context.Faculties on cs.FacultyID equals f.ID
                                  into f
                                  from cf in f.DefaultIfEmpty()
                                  where cs.CourseID == course.ID
                                  select new CourseSubject
                {
                    ID        = cs.ID,
                    SubjectID = cs.SubjectID,
                    FacultyID = cs.FacultyID,
                    Subject   = ms,
                    Faculty   = cf,
                    CourseID  = cs.CourseID
                };

                res.DepartmentList = _context.Departments.Where(d => d.Deleted != 1)
                                     .OrderByDescending(d => d.UpdatedAt)
                                     .Select(d => new DepartmentSelectDTO
                {
                    ID   = (int)d.ID,
                    Name = d.Name
                });

                return(View(res));
            }
            catch (Exception ex)
            {
                TempData["Error"] = ex.Message;
                return(RedirectToAction(nameof(Index)));
            }
        }