// GET: StudyResource
public async Task<ActionResult> Course()
{
ViewBag.Title = "课程介绍";
CourseViewModel viewmodel = new CourseViewModel();
viewmodel.Course = await CourseService.getCourseById(Session["CourseId"].ToString());
return View(viewmodel);
}
public Course(CourseViewModel courseVM)
{
this.Id = courseVM.Id;
this.Name = courseVM.Name;
this.Assignments = new List<Assignment>();
foreach(AssignmentViewModel assignmentVM in courseVM.Assignments)
{
this.Assignments.Add(new Assignment(assignmentVM));
}
}
public JsonResult UpdateCourse([DataSourceRequest] DataSourceRequest request, CourseViewModel course)
{
if (course == null || !ModelState.IsValid)
{
return Json(new[] { course }.ToDataSourceResult(request, ModelState), JsonRequestBehavior.AllowGet);
}
var updatedCourse = this.coursesServices.UpdateCourse(course);
return Json((new[] { updatedCourse }.ToDataSourceResult(request, ModelState)), JsonRequestBehavior.AllowGet);
}
private void addAssignmentTab(CourseViewModel course)
{
TabPage tab = new TabPage(course.Name);
DataGridView dgAssignments = new AssignmentGrid();
dgAssignments.Dock = DockStyle.Fill;
dgAssignments.DataSource = course.Assignments;
tab.Controls.Add(dgAssignments);
tab.DataBindings.Add(new Binding("Text", course, "Name"));
this.Controls.Add(tab);
}
private void addCourseTab(CourseViewModel course)
{
TabPage tab = new TabPage(course.Name);
GradeGrid dgGrades = new GradeGrid();
dgGrades.Course = course;
dgGrades.Dock = DockStyle.Fill;
tab.Controls.Add(dgGrades);
tab.DataBindings.Add(new Binding("Text", course, "Name"));
this.Controls.Add(tab);
}
public Design()
{
var moodleService = new DesignMoodleService();
var course = moodleService.GetCoursesAsync( null, CancellationToken.None ).Result.Courses[0];
Course = new CourseViewModel( new DesignDataCache(), new DesignSecureRequestHandler(), moodleService,
new DesignMoodleDownloader(), new DesignFileStorage(), new DesignBrowserService(),
course );
Main = new MainViewModel( new DesignDataCache(), new DesignSecureRequestHandler(), new DesignNavigationService(), new DesignMoodleService() );
Course.OnNavigatedToAsync();
Main.OnNavigatedToAsync();
}
// public static void AddCourse(CourseViewModel course)
// {
// SWC_LMSEntities context = new SWC_LMSEntities();
// {
// var startDate = DateTime.Parse(course.StartDate);
// var endDate = DateTime.Parse(course.EndDate);
// context.AddCourse(course.CourseId, course.SubjectId, course.CourseName, course.CourseDescription, course.IsArchived, startDate, endDate);
//context.SaveChanges();
// }
// }
public static void EditCourse(CourseViewModel course)
{
SWC_LMSEntities context = new SWC_LMSEntities();
{
Course newCourse = new Course();
newCourse.CourseName = "Test Info";
newCourse.CourseDescription = "Test Info Desc";
newCourse.StartDate = DateTime.Now;
newCourse.EndDate = DateTime.Now;
context.Courses.Add(newCourse);
context.SaveChanges();
}
}
public ActionResult Create(CourseViewModel courseViewModel)
{
if (ModelState.IsValid)
{
var imagePath = FileUploadHelper.UploadImage(courseViewModel.CourseImage, string.Format(ImagesFolderFormat, courseViewModel.CourseImage.FileName));
var course = Mapper.Map<Course>(courseViewModel);
course.ImageUrl = imagePath;
_coursesService.Create(course);
return RedirectToAction("Index");
}
SetRelatedItemsInViewBag(null);
return View(courseViewModel);
}
public ActionResult CreateCourse(CourseViewModel courseViewModel)
{
/* Check if there are errors in the submission */
if (ModelState.IsValid == false)
{
return View("CreateCourse");
}
/* Create a new course object with the submitted data and store in the application state */
HttpContext.Application.Lock();
HttpContext.Application["course"] = new Course(courseViewModel.Number, courseViewModel.Name);
HttpContext.Application.UnLock();
return RedirectToAction("AddStudent");
}
public CourseViewModel UpdateCourse(CourseViewModel course)
{
var courseFromDb = this.Data.Courses
.GetById(course.Id);
courseFromDb.Name = course.Name;
courseFromDb.Description = course.Description;
courseFromDb.IndividualCoursePrice = course.IndividualCoursePrice;
courseFromDb.CourseTypeId = course.CourseTypeId;
this.Data.SaveChanges();
var updatedCourse = this.GetCourseById(course.Id);
return updatedCourse;
}
public DispatchComposeViewModel(IViewContainer container, ViewModelRelationship parent,
ClassroomViewModel classroomViewModel,
CourseViewModel courseViewModel,
string sessionId)
{
Parent = parent;
refClassroomViewModel = classroomViewModel;
refCourseViewModel = courseViewModel;
Container = container;
SessionId = sessionId;
Provider = new DispatchManageProvider();
Provider.DispatchManageEvent = DispatchManageLoadedEvent;
Provider.DispatchManageEvent += (parent.ViewModel as DispatchManageViewModel).DispatchManageLoadedEvent;
userMgrProvider = new UserManageProvider();
userMgrProvider.ProfileEvent = ProfileELoadedEvent;
}
public List <CourseViewModel> GetAllCourses()
{
IEnumerable <Course> allCourses = from courses in _db.courses
select courses;
List <CourseViewModel> courseViewModelList = new List <CourseViewModel>();
foreach (var course in allCourses)
{
CourseViewModel courseViewModel = new CourseViewModel();
courseViewModel.Title = course.Title;
courseViewModel.Assignments = _assignmentsService.GetAssignmentsInCourse(course.Id);
courseViewModel.Id = course.Id;
courseViewModel.Description = course.Description;
courseViewModelList.Add(courseViewModel);
}
return(courseViewModelList);
}
// GET: School/Course/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var course = _courseRepository.GetCourseById(id);
CourseViewModel vm = new CourseViewModel();
vm.Id = course.Id;
vm.CourseName = course.CourseName;
vm.CourseCode = course.CourseCode;
if (vm == null)
{
return(HttpNotFound());
}
return(View(vm));
}
public Course Insert(CourseViewModel model)
{
var findResult = Queryable().Where(x => x.CourseName.ToLower().Trim() == model.CourseName.ToLower().Trim() && x.Delete == false).FirstOrDefault();
if (findResult != null)
{
throw new Exception("Course existed");
}
else
{
var data = new Course();
data.CourseName = model.CourseName;
data.CourseCode = model.CourseCode;
data.CreatDate = DateTime.Now;
data.LastModifiedDate = DateTime.Now;
base.Insert(data);
return(data);
}
}
public IActionResult Grid_Delete(CourseViewModel courseVm)
{
if (ModelState.IsValid)
{
var course = _courseService.Get(courseVm.Id);
if (course == null)
{
ModelState.AddModelError("CourseNotFound", "No course was found with the given Id.");
}
if (ModelState.IsValid)
{
_courseService.Delete(courseVm.Id);
}
}
return(Json(ModelState.ToDataSourceResult()));
}
public ActionResult Create(CourseViewModel model)
{
string getuser = User.Identity.GetUserId();
if (ModelState.IsValid)
{
Course course = AutoMapper.Mapper.Map <Course>(model);
course.CourseCode = Regex.Replace(model.CourseName, @"\s", "");
course.User = this.Data.Users.SearchFor(u => u.Id == getuser).SingleOrDefault();
this.Data.Courses.Add(course);
this.Data.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.CategoryId = new SelectList(this.Data.Categories.All(), "CategoryId", "CategoryName", model.CategoryId);
ModelState.AddModelError(String.Empty, "Course already Created. Choose different Name");
return(View(model));
}
// GET: Course/Edit/5
public IActionResult Edit(int?id)
{
if (id == null)
{
return(NotFound());
}
Course course = _courseManager.Get(id);
if (course == null)
{
return(NotFound());
}
else
{
CourseViewModel courseViewModel = MapToCourseViewModel(course);
return(View(courseViewModel));
}
}
private double calculateStudentTotalGradePercentage(StudentViewModel student)
{
int totalCoursePoints = 0;
int totalStudentPoints = 0;
foreach (GradingPeriodViewModel gradingPeriod in this.gradingPeriods)
{
CourseViewModel course = findCourse(gradingPeriod);
totalCoursePoints += course.getTotalPoints();
totalStudentPoints += course.getStudentPoints(student);
}
if (totalCoursePoints == 0)
{
return(1.0);
}
return(Convert.ToDouble(totalStudentPoints) / Convert.ToDouble(totalCoursePoints));
}
/// <summary>
/// Creates the course.
/// </summary>
/// <param name="unitViewModel">The course view model.</param>
public void CreateCourse(CourseViewModel courseViewModel)
{
try
{
if (courseViewModel != null)
{
courseViewModel.Accreditation_Id = courseViewModel.Accreditation_Id == 0 ? (int)AccreditationType.NotSpecified : courseViewModel.Accreditation_Id;
courseViewModel.CompanyId = courseViewModel.CompanyId == 0 ? (int)CompanyEnum.Trust : courseViewModel.CompanyId;
courseViewModel.CourseTemplate_Id = courseViewModel.CourseTemplate_Id == 0 ? (int)CourseTemplateEnum.DefaultTemplate : courseViewModel.CourseTemplate_Id;
Course course = ObjectMapper.Map <CourseViewModel, Model.Entities.Course>(courseViewModel);
course = CourseManager.Add(course);
}
}
catch (Exception ex)
{
ExceptionManager.HandleException(ex, PolicyNameType.ExceptionReplacing);
}
}
public ActionResult Edit(int id)
{
var course = _db.Courses.Find(id);
if (course == null)
{
return(HttpNotFound());
}
var viewModel = new CourseViewModel
{
Course = course,
Courses = _db.Courses.ToList(),
Instructors = _db.Instructors.ToList(),
Departments = _db.Departments.ToList()
};
return(View(viewModel));
}
public ActionResult Detail(int id)
{
var userId = User.Identity.GetUserId();
var viewModel = new CourseViewModel();
var course = _dbContext.Course.Where(c => c.Id == id).Include(a => a.Lecturer).Include(a => a.Category);
var listOfAttendedCourses = _dbContext.Attendance
.Include(a => a.Course)
.Include(a => a.Attendee)
.Where(a => a.AttendeeId == userId).ToList();
viewModel = new CourseViewModel
{
ListOfAttendedCourses = listOfAttendedCourses,
UpCommingCourses = course,
ShowAction = User.Identity.IsAuthenticated
};
return(View(viewModel));
}
public ActionResult SaveCourse(CourseViewModel courseData)
{
Department department = departmentService.GetDepartmentByName(courseData.Department);
Level level = levelService.GetLevelBySemester(courseData.Level);
//courseService = new CourseService();
Course Course = new Course()
{
DepartmentID = department.DepartmentID,
LevelID = level.LevelID,
Name = courseData.Name,
Description = courseData.Description,
Credit = courseData.Credit,
Duration = courseData.Duration,
InsertedDate = DateTime.Now,
};
courseService.SaveCourse(Course);
return(View(courseData));
}
public async Task <IActionResult> New()
{
var svgs = await _unitOfWork.Svgs.GetAllAsync();
var tags = await _unitOfWork.Tags.GetAllAsync();
var viewModel = new CourseViewModel()
{
Course = new CourseDto()
{
Svg = svgs.First(),
SvgId = svgs.First().Id,
},
Svgs = svgs.ToList(),
Tags = tags.ToList()
};
return(View(viewModel));
}
public async Task <IActionResult> Create(CourseViewModel model)
{
try
{
if (ModelState.IsValid)
{
await _courseService.Post(model.ToCourse());
return(RedirectToAction(nameof(Index)));
}
return(View(model));
}
catch
{
ViewData["errorMessage"] = "Error to create course";
return(View(model));
}
}
public async Task AddCourseDatesAsync(CourseViewModel model)
{
foreach (var date in model.CourseDates)
{
if (CourseDateExists(date.CourseDateId))
{
var existing = _context.CourseDates.Find(date.CourseDateId);
_context.Remove(existing);
await _context.SaveChangesAsync();
_context.Add(date);
}
else
{
_context.Add(date);
}
}
await _context.SaveChangesAsync();
}
public ActionResult Update(CourseViewModel viewModel)
{
if (!ModelState.IsValid)
{
ViewBag.Categories = _dbContext.Categories.ToList();
return(View("Create", viewModel));
}
var userId = User.Identity.GetUserId();
var course = _dbContext.Courses.Single(c => c.Id == viewModel.Id && c.LecturerId == userId);
course.Place = viewModel.Place;
course.DateTime = viewModel.GetDateTme();
course.CategoryId = viewModel.Category;
_dbContext.SaveChanges();
return(RedirectToAction("Index", "Home"));
}
public ActionResult Create(CourseViewModel viewModel)
{
if (!ModelState.IsValid)
{
viewModel.Categories = _dbContext.Categories.ToList();
return(View("Create", viewModel));
}
var course = new Course
{
Lecturer_Id = User.Identity.GetUserId(),
Datetime = viewModel.GetDateTime(),
CategoryId = viewModel.Category,
Place = viewModel.Place
};
_dbContext.Courses.Add(course);
_dbContext.SaveChanges();
return(RedirectToAction("Index", "Home"));
}
//[Authorize(Roles = "Staff")]
public ActionResult Edit(int id)
{
var CourseInDb = _context.Courses.SingleOrDefault(c => c.Id == id);
if (CourseInDb == null)
{
return(HttpNotFound());
}
var viewModel = new CourseViewModel
{
Course = CourseInDb,
Categories = _context.Categories,
Topics = _context.Topics
.ToList()
};
return(View(viewModel));
}
public ActionResult Edit(int id)
{
var userId = User.Identity.GetUserId();
var course = _dbContext.Courses.Single(c => c.Id == id && c.LecturerId == userId);
var viewModel = new CourseViewModel
{
Categories = _dbContext.Categories.ToList(),
Date = course.DateTime.ToString("dd/M/yyyy"),
Time = course.DateTime.ToString("HH:mm"),
Category = course.CategoryId,
Place = course.Place,
Heading = "Edit Courses",
Id = course.Id
};
return(View("Create", viewModel));
}
public ActionResult DeleteCourse(Guid courseId)
{
var deletedCourse = Courses.DeleteCourse(courseId);
if (ReferenceEquals(deletedCourse.GetType(), typeof(ErrorDomainModel)))
{
return(GradeTrackerError(deletedCourse, null));
}
else
{
var castedDomainModel = (CourseDomainModel)deletedCourse;
var courseIdOnlyModel = new CourseViewModel {
StudentId = castedDomainModel.StudentId
};
return(View("CourseDeleted", courseIdOnlyModel));
}
}
public IActionResult OnGet(int?id)
{
CourseVM = new CourseViewModel()
{
Course = new Course(),
Department = _deptRepo.GetDepartmentListOfDropDown(),
};
if (id != null)
{
var courseFromDb = _courseRepo.GetFisrtOrDefault(m => m.Id == id);
if (courseFromDb == null)
{
return(NotFound());
}
CourseVM.Course = courseFromDb;
}
return(Page());
}
public IActionResult Edit(int id, CourseViewModel model)
{
var course = _courseService.GetById(id);
if (course == null)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(View(model));
}
model.ToEntityModel(course);
_courseService.Update(course);
return(RedirectToAction("Index"));
}
public MainWindow()
{
InitializeComponent();
var course1 = new CourseViewModel()
{
Name = "Course1"
};
course1.Students.Add(new StudentViewModel()
{
Weight = 100, Name = "Mark"
});
course1.Students.Add(new StudentViewModel()
{
Weight = 120, Name = "Olaf"
});
course1.Students.Add(new StudentViewModel()
{
Weight = 111, Name = "Hans"
});
var course2 = new CourseViewModel()
{
Name = "Course2"
};
course2.Students.Add(new StudentViewModel()
{
Weight = 100, Name = "Mark"
});
course2.Students.Add(new StudentViewModel()
{
Weight = 90, Name = "Renate"
});
course2.Students.Add(new StudentViewModel()
{
Weight = 78, Name = "Judy"
});
DataContext = new List <CourseViewModel>()
{
course1,
course2
};
}
public ActionResult Attending()
{
var userId = User.Identity.GetUserId();
var courses = _dbContext.Attendances
.Where(a => a.AttendeeId == userId)
.Select(a => a.Course)
.Include(l => l.Lecturer)
.Include(l => l.Category)
.ToList();
var viewModel = new CourseViewModel
{
UpcommingCourses = courses,
ShowAction = User.Identity.IsAuthenticated
};
return(View(viewModel));
}
public IActionResult Details(int id)
{
var course = _repository.GetCourseById(id);
var teacher = _repository.GetTeacherById(course.TeacherId);
if (course == null)
{
return(NotFound());
}
var model = new CourseViewModel()
{
CourseId = course.CourseId,
CourseName = course.CourseName,
CourseType = course.CourseType,
};
return(View(model));
}
public async Task <ActionResult> EditCourse(CourseViewModel course)
{
string currentUserId = System.Web.HttpContext.Current.User.Identity.GetUserId();
if (currentUserId == null)
{
return(new HttpUnauthorizedResult());
}
ViewBag.SpecialityName = (await CourseService.GetAsync(course.Id)).Speciality.SpecialityName;
ViewBag.ParentId = course.SpecialityId;
ViewBag.Action = "SpecialityCourses";
if (ModelState.IsValid)
{
CourseDTO courseDTO = new CourseDTO
{
CourseId = course.Id,
SpecialityId = course.SpecialityId,
CourseTitle = course.Name,
Description = course.Description,
CourseTestQuestionsNumber = course.CourseTestQuestionsNumber,
TopicTestQuestionsNumber = course.TopicTestQuestionsNumber,
TimeToAnswerOneQuestion = course.TimeToAnswerOneQuestion,
AttemptsNumber = course.AttemptsNumber,
PassingScore = course.PassingScore,
IsApproved = course.IsApproved,
IsFree = course.IsFree
};
OperationDetails operationDetails = await CourseService.UpdateAsync(courseDTO, currentUserId);
if (operationDetails.Succedeed)
{
return(PartialView("Report", operationDetails));
}
else
{
ModelState.AddModelError(operationDetails.Property, operationDetails.Message);
return(PartialView("Report", operationDetails));
}
}
ViewBag.Message = "Non valid";
return(PartialView("~/Views/Admin/Course/EditCourse.cshtml", course));
}
public ActionResult CourseDetail(int courseId)
{
CourseViewModel vm = new CourseViewModel();
//课程
CourseInfoListDto courseInfo = _courseInfoAppService.GetCourseInfoById(new EntityDto <long>()
{
Id = courseId
});
courseInfo.Content = System.Web.HttpUtility.HtmlDecode(courseInfo.Content);
//内训师
int teacherId = courseInfo.TeacherId;
var teacher = _teachersAppService.GetTeachersById(new EntityDto <long>()
{
Id = teacherId
});
int userId = int.Parse(CookieHelper.GetCookieValue("UserId").ToString());
//是否已报名
var boundData = _courseBoundPersonnelAppService.GetCourseBoundByUserIdOrCourseId(userId, courseId);//绑定数据
if (boundData != null)
{
vm.IsSingleUp = true;
}
else
{
vm.IsSingleUp = false;
}
if (courseInfo.Status == 4)
{
vm.IsComplete = true;
}
else
{
vm.IsComplete = false;
}
vm.teacher = teacher;
vm.CourseInfo = courseInfo;
vm.CourseId = courseId;
return(View(vm));
}
public async Task <ActionResult> CourseInfo()
{
DateTime start = DateTime.Now;
// begin action
// get user id
string userId = User.Identity.GetUserId();
// get all classes in "tu-vung" course
var course = await m_courseService.GetCourseByIdAsync(Constraint.HepaCourse.TU_VUNG);
// create list of classes
IList <ClassSummaryViewModel> listClassesSummary = new List <ClassSummaryViewModel>();
// get all class
IList <Class> allClasses = await this.m_classService.GetAllClassOfCourseAsync(Constraint.HepaCourse.TU_VUNG);
// add more info for class summary
foreach (Class classElement in allClasses)
{
// check if registered
bool isRegisterd = await this.m_classService.IsUserRegisteredClassAsync(userId, classElement.Id);
// Update class dedatils
// get archieve amount
var achievingAmount = m_learnWordService.GetUserPassedWordAmountCount(userId, classElement.Id);
// passed today
int passedToDayWords = await m_learnWordService.NumberOfPassedWordsTodayAsync(userId, classElement.Id);
// get number of words user has learned today
int numberOfWords = await this.m_learnWordService.NumberOfTodayWordsAsync(userId, classElement.Id);
// create element
ClassSummaryViewModel classSummaryElement = new ClassSummaryViewModel(classElement, isRegisterd, 0, achievingAmount, numberOfWords, passedToDayWords);
// Add element
listClassesSummary.Add(classSummaryElement);
}
CourseViewModel model = new CourseViewModel(listClassesSummary, course);
// date time
System.Diagnostics.Debug.WriteLine("Course info: " + (DateTime.Now - start));
// return model
return(View(model));
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.UseRouting();
app.UseEndpoints(endpoints =>
{
endpoints.MapGet("/", async context =>
{
using var dbContext = context.RequestServices.GetService <MyDbContext>();
//When Skip and/or Take is used, the owned types CurrentPrice and FullPrice are null
var courseList1 = await dbContext.Courses
.Include(course => course.CurrentPrice)
.Select(course => CourseViewModel.FromEntity(course))
.Skip(0).Take(3)
.AsNoTracking()
.ToListAsync();
await context.Response.WriteAsync($"See? The CurrentPrice is null for these entites fetched with Skip/Take\r\n");
foreach (var course in courseList1)
{
await context.Response.WriteAsync($"Price: {(course.CurrentPrice?.ToString() ?? "null")}\r\n");
}
//No problem when Skip/Take are omitted
var courseList2 = await dbContext.Courses
.Include(course => course.CurrentPrice)
.Select(course => CourseViewModel.FromEntity(course))
.AsNoTracking()
.ToListAsync();
await context.Response.WriteAsync($"No problem whatsoever if Skip/Take are omitted\r\n");
foreach (var course in courseList2)
{
await context.Response.WriteAsync($"Price: {course.CurrentPrice}\r\n");
}
});
});
}
public ActionResult EnrolledStudents(CourseViewModel m)
{
try
{
DB41Entities db = new DB41Entities();
StudentViewModel s = new StudentViewModel();
EnrolledStudent n = new EnrolledStudent();
var Id = db.Courses
.Where(x => x.Title == m.Title)
.Select(x => x.CourseID)
.FirstOrDefault();
n.CourseID = Id;
n.StartDate = m.Start_date;
n.Duration = m.Course_duration;
n.Department = m.Department;
n.Fee = m.Fee;
var Ide = db.Instructors
.Where(x => x.Name == m.Instructor)
.Select(x => x.InstructorID)
.FirstOrDefault();
n.InstructorID = Ide;
string userid = User.Identity.GetUserId();
int g = Convert.ToInt32(userid);
var person = db.Students.Where(y => y.StudentID == g).First();
n.StudentName = person.Name;
n.CNIC = person.CNIC;
n.Address = s.Address;
n.Email = s.Email;
n.StudentID = person.StudentID;
db.EnrolledStudents.Add(n);
db.SaveChanges();
return(View("Index"));
}
catch (Exception e)
{
throw e;
}
}
public IActionResult CourseAjax(CRUD_ACTION m, CourseViewModel model)
{
if (m != CRUD_ACTION.delete && !ModelState.IsValid)
{
string[] errors = ModelState.Values.SelectMany(v => v.Errors).Select(v => v.ErrorMessage).ToArray();
return(Json(new { errors = errors }));
}
JsonResult result = Json("OK");
switch (m)
{
case CRUD_ACTION.create:
var insResult = _courseService.AddCourse(model);
if (insResult == 0) // set it to 0
{
return(Json(new { errors = new string[] { "Inserimento non riuscito.." } }));
}
break;
case CRUD_ACTION.update:
var upResult = _courseService.UpdateCourse(model);
if (upResult == 1) // set it to 0
{
return(Json(new { errors = new string[] { "Aggiornamento non riuscito.." } }));
}
break;
case CRUD_ACTION.delete:
var delResult = _courseService.RemoveCourse(model);
if (delResult == 0)
{
return(Json(new { errors = new string[] { "Eliminazione non riuscita.." } }));
}
break;
default:
return(Json(new { errors = new string[] { "Operazione non permessa" } }));
}
return(result);
}
public ActionResult Add(CourseViewModel input)
{
// Populate VM
var viewModel = PopulateViewModel(input);
// Check for already existing course
var courseExists = viewModel.RegisteredCourses.Find(c => c.Number == input.Number);
if (courseExists != null)
ModelState.AddModelError("Number", "ID already exists");
// Validate model state
if (!ModelState.IsValid)
return View(viewModel);
// Insert course into database via repository
_courseService.AddCourse(new Course(input.Number, input.Name, input.WeeklyHours));
return RedirectToAction("Add");
}
public void SaveNoteToInstructorEnrollmentRecord(CourseViewModel form, Enrollment enrollment, ModelStateDictionary modelState, ApplicationUser instructor)
{
if (enrollment != null)
{
if (modelState.IsValid)
{
if (HttpUtility.HtmlDecode(form.EnrollmentNote) != null)
{
enrollment.Note = HttpUtility.HtmlDecode(form.EnrollmentNote);
enrollment.ApplicationUser = instructor;
_context.Entry(enrollment).State = EntityState.Modified;
try
{
_context.SaveChanges();
}
catch (DbEntityValidationException ex)
{
var sb = new StringBuilder();
foreach (DbEntityValidationResult failure in ex.EntityValidationErrors)
{
sb.AppendFormat("{0} failed validation\n", failure.Entry.Entity.GetType());
foreach (DbValidationError error in failure.ValidationErrors)
{
sb.AppendFormat("- {0} : {1}", error.PropertyName, error.ErrorMessage);
sb.AppendLine();
}
}
throw new DbEntityValidationException(
"Entity Validation Failed - errors follow:\n" +
sb, ex
); // Add the original exception as the innerException
}
}
}
}
}
public JsonResult DestroyCourse([DataSourceRequest] DataSourceRequest request, CourseViewModel course)
{
var deletedCourse = this.coursesServices.DestroyCourse(course.Id);
return Json(new[] { deletedCourse }, JsonRequestBehavior.AllowGet);
}
public IHttpActionResult AddCourse(CourseViewModel courseVM)
{
if (!ModelState.IsValid)
{
throw new HttpResponseException(HttpStatusCode.PreconditionFailed);
}
CourseDTO courseDTO = null;
try
{
courseDTO = _service.AddCourse(courseVM);
}
catch (AppObjectNotFoundException)
{
throw new HttpResponseException(HttpStatusCode.NotFound);
}
var location = Url.Link("GetCourseByID", new { ID = courseDTO.ID });
return Created(location, courseDTO);
}
/// <summary>
/// Adds a course.
/// </summary>
/// <param name="courseVM">The course view model.</param>
/// <returns>Returns the course DTO. Or null if there's no matching course template.</returns>
public CourseDTO AddCourse(CourseViewModel courseVM)
{
//Find the name for the course
string courseName = (from c in _context.Courses
join ct in _context.CourseTemplates
on c.TemplateID equals ct.TemplateID
where ct.TemplateID == courseVM.TemplateID
select ct.Name).FirstOrDefault();
if (string.IsNullOrEmpty(courseName))
{
return null; //If there is no course with the given templateID, we return null..
}
Course course = new Course { TemplateID = courseVM.TemplateID, StartDate = courseVM.StartDate, EndDate = courseVM.EndDate, Semester = courseVM.Semester };
_context.Courses.Add(course);
_context.SaveChanges();
//EF is brilliant.. adds the ID to the Course..
return new CourseDTO { ID = course.ID, Name = courseName, Semester = course.Semester, StartDate = course.StartDate };
}
/// <summary>
/// Adds a course.
/// </summary>
/// <exception cref="AppObjectNotFoundException">Thrown if we can't find a course with the given templateID.</exception>
/// <param name="courseVM">The course view model.</param>
/// <returns>Returns the course DTO.</returns>
public CourseDTO AddCourse(CourseViewModel courseVM)
{
//Find the name for the course
string courseName = _context.CourseTemplates.Where(ct => ct.TemplateID == courseVM.TemplateID).Select(ct => ct.Name).SingleOrDefault();
if (string.IsNullOrEmpty(courseName))
{
throw new AppObjectNotFoundException();
}
Course course = new Course { TemplateID = courseVM.TemplateID, StartDate = courseVM.StartDate, EndDate = courseVM.EndDate, Semester = courseVM.Semester, MaxStudents = courseVM.MaxStudents };
_context.Courses.Add(course);
_context.SaveChanges();
//EF is brilliant.. adds the ID to the Course..
return new CourseDTO { ID = course.ID, Name = courseName, Semester = course.Semester, StartDate = course.StartDate, MaxStudents = course.MaxStudents };
}
public ActionResult Destroy([DataSourceRequest]DataSourceRequest request, CourseViewModel model)
{
this.courseService.DeleteById(model.Id);
RouteValueDictionary routeValues = this.GridRouteValues();
return this.RedirectToAction("Index", routeValues);
}
public IHttpActionResult AddCourse(CourseViewModel courseVM)
{
if (!ModelState.IsValid)
{
throw new HttpResponseException(HttpStatusCode.PreconditionFailed);
}
CourseDTO courseDTO = _service.AddCourse(courseVM);
//If the courseDTO is null, it means we didn't find a CourseTemplate with the given ID
if (courseDTO == null)
{
throw new HttpResponseException(HttpStatusCode.NotFound);
}
var location = Url.Link("GetCourseByID", new { ID = courseDTO.ID });
return Created(location, courseDTO);
}
// Populate Course View Model
public CourseViewModel PopulateViewModel(CourseViewModel viewModel)
{
viewModel.RegisteredCourses = _courseService.GetAllCourses().OrderBy(c => c.Name).ToList();
return viewModel;
}
public ActionResult Edit(int id, CourseViewModel courseViewModel)
{
if (!ModelState.IsValid)
{
return View(courseViewModel);
}
var courseInDb = _coursesService.GetById(id);
if (courseViewModel.CourseImage != null && courseViewModel.CourseImage.ContentLength != 0)
{
try
{
courseInDb.ImageUrl = FileUploadHelper.UploadImage(courseViewModel.CourseImage, string.Format(ImagesFolderFormat, courseViewModel.CourseImage.FileName));
}
catch (Exception exception)//TODO catch more specific exceptions and add more detailed messages
{
_logger.Error("There was a problem uploading course picture", exception);
ModelState.AddModelError(string.Empty, @"Файлът не може да бъде качен!");
SetRelatedItemsInViewBag(courseInDb);
return View(courseViewModel);
}
}
courseViewModel.ShortDescription = _sanitizer.Sanitize(courseViewModel.ShortDescription);
courseViewModel.DetailedDescription = _sanitizer.Sanitize(courseViewModel.DetailedDescription);
var course = Mapper.Map(courseViewModel, courseInDb);
_coursesService.Update(course);
return RedirectToAction("Index");
}
