// GET: Courses/PartialDetails/5
public async Task <IActionResult> PartialDetails(int?id)
{
if (id == null)
{
return(NotFound());
}
var course = await db.Courses
.FirstOrDefaultAsync(m => m.Id == id);
var teachers = await userManager.GetUsersInRoleAsync("Teacher");
var teacher = teachers.FirstOrDefault(s => s.CourseId == id);
var viewModel = new CourseDetailsViewModel();
viewModel.Course = course;
if (teacher is null)
{
viewModel.TeacherName = "No teacher chosen";
}
else
{
viewModel.TeacherName = teacher.FullName;
}
if (course == null)
{
return(NotFound());
}
return(PartialView("CoursePartialDetails", viewModel));
}
public async Task <IActionResult> Details(int courseId)
{
Course courseFromDB = _coursesRepository.GetById(courseId);
SubjectViewModel subjectFromDB = _subjectsRepository.GetById(courseFromDB.Subject.SubjectId);
List <CourseModuleEditViewModel> modulesFromDB = await _coursesRepository.GetScheduleModules(courseId);
List <Student> students = await _studentsRepository.GetStudentsByCourse(courseId);
User userFromDB = await _usersRepository.GetByEmail(courseFromDB.Teacher.Email);
CourseDetailsViewModel courseDetailsViewModel = new CourseDetailsViewModel()
{
Course = courseFromDB,
Subject = new Subject()
{
SubjectId = subjectFromDB.SubjectId,
Name = subjectFromDB.Name,
Description = subjectFromDB.Description
},
Teacher = new AspNetUsers()
{
FirstName = userFromDB.FirstName,
LastName = userFromDB.LastName,
MiddleName = userFromDB.MiddleName
},
Modules = modulesFromDB,
Students = students
};
return(View(courseDetailsViewModel));
}
public void Test_ExtractSectionRatings_with_ValidCourse()
{
// Arrange
CourseModel dummy_courseToAttach = new CourseModel();
dummy_courseToAttach.Id = "1010";
dummy_courseToAttach.Department = "COMP";
dummy_courseToAttach.Difficulty = 7.62;
dummy_courseToAttach.DifficultyCount = 1;
dummy_courseToAttach.SectionRatings = new Dictionary <string, Dictionary <string, double> >
{
{ "test_person", new Dictionary <string, double> {
{ "rating", 9.76 }, { "count", 4 }
} }
};
var testCourseDetailsVM = new CourseDetailsViewModel(dummy_courseToAttach);
// Act
testCourseDetailsVM.ExtractSectionRatings();
// Assert
Assert.IsTrue(testCourseDetailsVM.SectionRatings.Count == dummy_courseToAttach.SectionRatings.Count, "Not all section ratings were extracted in VM");
Assert.IsTrue(testCourseDetailsVM.SectionRatings.Any(s => s.Name == "test_person" && s.Rating == 9.76 && s.Count == 4), "Could not find a section rating with provided test dummy data");
}
// GET: Courses/Details/5
public async Task <IActionResult> Details(int?id, int?studentId)
{
ViewBag.StudentId = studentId;
if (id == null)
{
return(NotFound());
}
CourseDetailsViewModel model = new CourseDetailsViewModel
{
Course = await _context.Courses.Include(c => c.Department)
.AsNoTracking()
.SingleOrDefaultAsync(m => m.CourseID == id)
};
if (model.Course == null)
{
return(NotFound());
}
model.OtherCourses = await _context.Courses
.Where(c => c.CourseID != id && c.DepartmentID == model.Course.DepartmentID)
.ToListAsync();
return(View(model));
}
public void Test_ExtractSectionRatings_with_InvalidSections()
{
// Arrange
CourseModel dummy_courseToAttach = new CourseModel();
dummy_courseToAttach.Id = "1010";
dummy_courseToAttach.Department = "COMP";
dummy_courseToAttach.Difficulty = 7.62;
dummy_courseToAttach.DifficultyCount = 1;
dummy_courseToAttach.SectionRatings = new Dictionary <string, Dictionary <string, double> >
{
{ "test_person", new Dictionary <string, double> {
{ "NOrating", 9.76 }, { "NOcount", 4 }
} }
};
var testCourseDetailsVM = new CourseDetailsViewModel(dummy_courseToAttach);
// Act
testCourseDetailsVM.ExtractSectionRatings();
// Assert
Assert.IsTrue(testCourseDetailsVM.SectionRatings.Count == 0, "Sections should not exist for course with invalid section data");
}
public CourseDetailsViewModel GetDetails(int id)
{
var rand = new Random();
var price = Convert.ToDecimal(rand.NextDouble() * 10 + 10);
var courseDetails = new CourseDetailsViewModel
{
Id = id,
Title = $"Corso{id}",
CurrentPrice = new Money(Currency.EUR, price),
FullPrice = new Money(Currency.EUR, rand.NextDouble() > 0.5 ? price : price - 1),
Author = "Nome Cognome",
Rating = rand.NextDouble() * 5.0,
Description = $"Description{id}",
ImagePath = "~/logo.svg",
Lessons = new List <LessonViewModel>()
};
for (var i = 1; i <= 5; ++i)
{
var lesson = new LessonViewModel
{
Title = $"Lesson{i}",
Duration = TimeSpan.FromSeconds(rand.Next(40, 90))
};
courseDetails.Lessons.Add(lesson);
}
return(courseDetails);
}
public void ShowProviderDetailsPhoneNumberTest(bool providerDetailsExist)
{
// Arrange
var courseDetailsProviderDetails = new _MVC_Views_CourseDetails_Provider_cshtml();
var providerDetails = new ProviderDetails();
var courseDetailsViewModel = new CourseDetailsViewModel();
courseDetailsViewModel.CourseDetails.ProviderDetails = providerDetails;
if (providerDetailsExist)
{
courseDetailsViewModel.CourseDetails.ProviderDetails.PhoneNumber = nameof(CourseDetails.ProviderDetails.PhoneNumber);
}
else
{
courseDetailsViewModel.CourseDetails.ProviderDetails.PhoneNumber = null;
}
// Act
var htmlDocument = courseDetailsProviderDetails.RenderAsHtml(courseDetailsViewModel);
// Assert
if (providerDetailsExist)
{
htmlDocument.DocumentNode.Descendants("li")
.Any(li => li.InnerText.Contains(courseDetailsViewModel.CourseDetails.ProviderDetails.PhoneNumber)).Should().BeTrue();
}
else
{
htmlDocument.DocumentNode.Descendants("li")
.Any(li => li.InnerText.Contains(courseDetailsViewModel.CourseDetails.ProviderDetails.PhoneNumber)).Should().BeFalse();
}
}
public void ShowHideBackToResultsTest(bool referralUrlExists)
{
// Arrange
var courseDetailsHtml = new _MVC_Views_CourseDetails_CourseDetails_cshtml();
var courseDetailsViewModel = new CourseDetailsViewModel();
var courseDetails = new CourseDetails();
if (referralUrlExists)
{
courseDetailsViewModel.ReferralPath = nameof(CourseDetailsViewModel.ReferralPath);
}
else
{
courseDetailsViewModel.ReferralPath = null;
}
// Act
var htmlDocument = courseDetailsHtml.RenderAsHtml(courseDetailsViewModel);
// Assert
if (referralUrlExists)
{
htmlDocument.DocumentNode.Descendants("a")
.Any(a => a.Attributes["class"].Value.Contains("govuk-back-link") &&
a.Attributes["href"].Value.Contains(courseDetailsViewModel.ReferralPath)).Should().BeTrue();
}
else
{
htmlDocument.DocumentNode.Descendants("a")
.Any(a => a.Attributes["class"].Value.Contains("govuk-back-link") &&
a.Attributes["href"].Value.Contains(courseDetailsViewModel.ReferralPath)).Should().BeFalse();
}
}
public void ShowProviderDetailsEmailAddressTest(bool providerDetailsExist)
{
// Arrange
var courseDetailsProviderDetails = new _MVC_Views_CourseDetails_Provider_cshtml();
var providerDetails = new ProviderDetails();
var courseDetailsViewModel = new CourseDetailsViewModel();
courseDetailsViewModel.CourseDetails.ProviderDetails = providerDetails;
if (providerDetailsExist)
{
courseDetailsViewModel.CourseDetails.ProviderDetails.EmailAddress = nameof(CourseDetails.ProviderDetails.EmailAddress);
}
// Act
var htmlDocument = courseDetailsProviderDetails.RenderAsHtml(courseDetailsViewModel);
// Assert
if (providerDetailsExist)
{
htmlDocument.DocumentNode.Descendants("a")
.Any(a => a.Attributes["class"].Value.Contains("govuk-link") &&
a.InnerText.Contains(courseDetailsViewModel.CourseDetails.ProviderDetails.EmailAddress)).Should().BeTrue();
}
else
{
htmlDocument.DocumentNode.Descendants("a")
.Any(a => a.Attributes["class"].Value.Contains("govuk-link") &&
a.InnerText.Contains(courseDetailsViewModel.CourseDetails.ProviderDetails.EmailAddress)).Should().BeFalse();
}
}
public IActionResult Index(string providerCode, string courseCode, ResultsFilter filter)
{
if (featureFlags.RedirectToRailsPageCourse)
{
return(redirectUrlService.RedirectToNewApp("/course/" + $"{providerCode}" + "/" + $"{courseCode}"));
}
var course = _api.GetCourse(providerCode, courseCode);
var feeCaps = _api.GetFeeCaps();
var latestFeeCaps = feeCaps.OrderByDescending(x => x.EndYear).FirstOrDefault();
if (course == null || latestFeeCaps == null)
{
return(NotFound());
}
var viewModel = new CourseDetailsViewModel()
{
Course = course,
Finance = new Shared.ViewModels.FinanceViewModel(course, latestFeeCaps),
PreviewMode = false
};
return(View(viewModel));
}
private bool ValidateCourseForEdit(Course courseToEdit, CourseDetailsViewModel viewModel, ModelStateDictionary modelState)
{
bool result = true;
if (viewModel != null)
{
if (viewModel.From.HasValue)
{
if (courseToEdit.CheckHasEnded())
{
modelState.AddModelError("Title", "Course has already ended");
result = false;
}
else
{
if (!courseToEdit.CheckHasStarted() && viewModel.From.Value.Date < DateTime.Today)
{
modelState.AddModelError("From", "From date must be greater than or equal to today");
result = false;
}
if (!courseToEdit.CheckHasStarted() && viewModel.To.Value.Date < DateTime.Today)
{
modelState.AddModelError("To", "To date must be greater than or equal to today");
result = false;
}
}
}
}
return(result);
}
public void CourseCanBeDelete()
{
DbContextOptions <Lab13StudentEnrollmentDbContext> options =
new DbContextOptionsBuilder <Lab13StudentEnrollmentDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options;
using (Lab13StudentEnrollmentDbContext context = new Lab13StudentEnrollmentDbContext(options))
{
Course course = new Course();
course.CourseID = "cs101";
course.Description = "Basic computer science class";
CoursesController cc = new CoursesController(context);
var x = cc.Create(course);
var retrieve = context.Courses.Where(c => course.CourseID == "cs101").ToList();
ViewResult current = (ViewResult)cc.Details(retrieve[0].ID).Result;
CourseDetailsViewModel test = (CourseDetailsViewModel)current.Model;
Assert.Equal("cs101", test.Course.CourseID);
x = cc.Delete(test.Course.ID);
retrieve = context.Courses.Where(c => c.CourseID == "cs101").ToList();
Assert.Empty(retrieve);
}
}
public ActionResult View(int id)
{
if (id <= 0)
{
return(RedirectToAction("Index"));
}
else
{
Course courseToView = unitOfWork.CoursesRepository.GetCourseById(id);
if (courseToView != null)
{
CourseDetailsViewModel viewModel = new CourseDetailsViewModel()
{
Id = courseToView.Id,
Title = courseToView.Title,
Description = courseToView.Description,
From = courseToView.From.Date,
To = courseToView.To.Date,
IsCancelled = courseToView.IsCancelled
};
return(View(viewModel));
}
else
{
return(RedirectToAction("Index"));
}
}
}
public void Test_GetContextedCourseVM_with_ValidCourse()
{
// Arrange
StubHttpConnection stub_connection = new StubHttpConnection();
List <CourseModel> test_courseList = new List <CourseModel>();
CourseModel dummy_courseToAttach = new CourseModel();
dummy_courseToAttach.Id = "1000";
dummy_courseToAttach.Department = "STAT";
dummy_courseToAttach.Name = "Should be in final list";
dummy_courseToAttach.Difficulty = 5.55;
dummy_courseToAttach.DifficultyCount = 9;
dummy_courseToAttach.SectionRatings = new Dictionary <string, Dictionary <string, double> >
{
{ "test_person1", new Dictionary <string, double> {
{ "rating", 6.9 }, { "count", 10 }
} }
};
DepartmentViewModel deptVmToTest = new DepartmentViewModel("TEST", stub_connection);
// Act
CourseDetailsViewModel courseVmToTest = deptVmToTest.GetContextedCourseVM(dummy_courseToAttach);
// Assert
Assert.IsTrue(courseVmToTest.DepartmentName.Equals("Department of " + dummy_courseToAttach.Department), "Returned contexted course had different department");
Assert.IsTrue(courseVmToTest.DifficultyLevel.Equals(dummy_courseToAttach.Difficulty), "Returned contexted course had difficulty level");
Assert.IsTrue(courseVmToTest.DifficultyCount.Equals("Based on " + dummy_courseToAttach.DifficultyCount + " reviews"), "Returned contexted course had difficulty count");
Assert.IsTrue(courseVmToTest.NameAndId.Equals(dummy_courseToAttach.Id + " - " + dummy_courseToAttach.Name), "Returned contexted course had different course name and id");
}
public ActionResult Subscribe(CourseDetailsViewModel model)
{
var userId = User.Identity.GetUserId();
_courseService.Subscribe(userId, model.Id);
return(RedirectToAction("Index"));
}
public void ShowProviderDetailsNameTest(bool providerDetailsExist)
{
// Arrange
var courseDetailsProviderDetails = new _MVC_Views_CourseDetails_Provider_cshtml();
var providerDetails = new ProviderDetails();
var courseDetailsViewModel = new CourseDetailsViewModel();
courseDetailsViewModel.CourseDetails.ProviderDetails = providerDetails;
if (providerDetailsExist)
{
courseDetailsViewModel.CourseDetails.ProviderDetails.Name = nameof(CourseDetails.ProviderDetails.Name);
}
else
{
courseDetailsViewModel.CourseDetails.ProviderDetails.Name = null;
}
// Act
var htmlDocument = courseDetailsProviderDetails.RenderAsHtml(courseDetailsViewModel);
// Assert
if (providerDetailsExist)
{
htmlDocument.DocumentNode.Descendants("p")
.Any(p => p.Attributes["class"].Value.Contains("govuk-body-lead") &&
p.InnerText.Contains(courseDetailsViewModel.CourseDetails.ProviderDetails.Name)).Should().BeTrue();
}
else
{
htmlDocument.DocumentNode.Descendants("p")
.Any(p => p.Attributes["class"].Value.Contains("govuk-body-lead") &&
p.InnerText.Contains(nameof(courseDetailsViewModel.CourseDetails.ProviderDetails.Name))).Should().BeFalse();
}
}
public async Task <CourseDetailsViewModel> GetDetailsAsync(int id)
{
CourseDetailsViewModel corsoDetails = await dbContext.Corsi.Where(corso => corso.Id == id)
.AsNoTracking()
.Select(corso =>
new CourseDetailsViewModel
{
Id = corso.Id,
Title = corso.Title,
Description = corso.Description,
ImagePath = corso.ImagePath,
Author = corso.Author,
Rating = corso.Rating,
CurrentPrice = corso.CurrentPrice,
FullPrice = corso.FullPrice,
Lessons = corso.Lessons.Select(lesson =>
new LessonViewModel
{
Id = lesson.Id,
Title = lesson.Title,
Description = lesson.Description,
Duration = lesson.Duration
}).ToList()
})
.SingleAsync();//Restituisce il primo elemento dell'elenco ma solleva un'eccezione se l'elenco è vuoto o ha più di un elemento univoco.
return(corsoDetails);
}
public ActionResult Create(CourseDetailsViewModel viewModel)
{
ActionResult result = null;
try
{
if (ModelState.IsValid && ValidateCourseForCreate(viewModel, ModelState) && !CheckCourseTitleAlreadyExists(viewModel.Title))
{
Course newCourse = new Models.Course(viewModel.Title, viewModel.Description, viewModel.From.Value, viewModel.To.Value);
unitOfWork.CoursesRepository.CreateCourse(newCourse, User.Identity.GetUserId());
unitOfWork.Complete();
Course course = unitOfWork.CoursesRepository.GetCourseById(newCourse.Id);
unitOfWork.CoursesAntenna.OnCourseCreated(course);
result = RedirectToAction("Index");
}
else
{
result = View(viewModel);
}
}
catch
{
result = View(viewModel);
}
return(result);
}
// ~/Course/Details/{id}
public IActionResult Details(int id)
{
var course = context.Courses.FirstOrDefault(c => c.Id == id);
if (course == null)
{
TempData["ErrorMessage"] = "Το μάθημα δε βρέθηκε.";
return(RedirectToAction("Index", "Course"));
}
var direction = context.Directions.FirstOrDefault(d => d.Id == course.DirectionId);
List <CourseInstructor> instructors = context
.CourseInstructors
.Include(item => item.Instructor)
.Where(ci => ci.CourseId == id)
.ToList();
CourseDetailsViewModel coursedetailsViewModel = new CourseDetailsViewModel()
{
Title = "Στοιχεία μαθήματος " + course.Title,
Course = course,
Direction = direction,
Instructors = instructors
};
return(View(coursedetailsViewModel));
}
public void ShowEntryRequirementsTest(bool hasValue)
{
// Arrange
var courseDetailsCourseDetails = new _MVC_Views_CourseDetails_CourseDetails_cshtml();
var courseDetailsViewModel = new CourseDetailsViewModel();
courseDetailsViewModel.CourseDetails = new CourseDetails();
if (hasValue)
{
courseDetailsViewModel.CourseDetails.EntryRequirements = nameof(CourseDetailsViewModel.CourseDetails.EntryRequirements);
}
else
{
courseDetailsViewModel.NoEntryRequirementsAvailableMessage = nameof(CourseDetailsViewModel.NoEntryRequirementsAvailableMessage);
}
// Act
var htmlDocument = courseDetailsCourseDetails.RenderAsHtml(courseDetailsViewModel);
// Assert
if (hasValue)
{
htmlDocument.DocumentNode.Descendants("p")
.Any(div => div.Attributes["class"].Value.Contains("govuk-body") &&
div.InnerText.Contains(courseDetailsViewModel.CourseDetails.EntryRequirements)).Should().BeTrue();
}
else
{
htmlDocument.DocumentNode.Descendants("p")
.Any(div => div.Attributes["class"].Value.Contains("govuk-body") &&
div.InnerText.Contains(courseDetailsViewModel.NoEntryRequirementsAvailableMessage)).Should().BeTrue();
}
}
public async Task <IActionResult> DetailsAsync(int id)
{
// var courseDetailsService = new CourseService();
CourseDetailsViewModel courseDetails = await courseService.GetDetailsAsync(id);
ViewData["Title"] = courseDetails.Title;
return(View(courseDetails));
}
public void Dfc9560MissingFieldsTest(CourseDetailsViewModel courseDetailsViewModel, CourseDetails courseDetails)
{
//Arrange
courseDetailsViewModel.CourseDetails = courseDetails;
var detailsView = new _MVC_Views_CourseDetails_CourseDetails_cshtml();
//Act
var htmlDocument = detailsView.RenderAsHtml(courseDetailsViewModel);
//Asserts
if (!string.IsNullOrWhiteSpace(courseDetails.AttendancePattern))
{
AssertTagInnerTextValue(htmlDocument, courseDetailsViewModel.AttendancePatternLabel, "th");
AssertTagInnerTextValue(htmlDocument, courseDetails.AttendancePattern, "td");
}
if (!string.IsNullOrWhiteSpace(courseDetails.AwardingOrganisation))
{
AssertTagInnerTextValue(htmlDocument, courseDetailsViewModel.AwardingOrganisationLabel, "th");
AssertTagInnerTextValue(htmlDocument, courseDetails.AwardingOrganisation, "td");
}
if (!string.IsNullOrWhiteSpace(courseDetails.CourseWebpageLink))
{
AssertTagInnerTextValue(htmlDocument, courseDetailsViewModel.CourseWebpageLinkLabel, "th");
AssertElementExistsByAttributeAndValue(htmlDocument, "a", "href", courseDetails.CourseWebpageLink);
}
if (!string.IsNullOrWhiteSpace(courseDetails.StudyMode))
{
AssertTagInnerTextValue(htmlDocument, courseDetailsViewModel.CourseTypeLabel, "th");
AssertTagInnerTextValue(htmlDocument, courseDetails.StudyMode, "td");
}
if (!string.IsNullOrWhiteSpace(courseDetails.AdditionalPrice))
{
AssertTagInnerTextValue(htmlDocument, courseDetailsViewModel.AdditionalPriceLabel, "th");
AssertTagInnerTextValue(htmlDocument, courseDetails.AdditionalPrice, "td");
}
if (!string.IsNullOrWhiteSpace(courseDetails.QualificationName))
{
AssertTagInnerTextValue(htmlDocument, courseDetailsViewModel.QualificationNameLabel, "th");
AssertTagInnerTextValue(htmlDocument, courseDetails.QualificationName, "td");
}
if (!string.IsNullOrWhiteSpace(courseDetails.QualificationLevel))
{
AssertTagInnerTextValue(htmlDocument, courseDetailsViewModel.QualificationLevelLabel, "th");
AssertTagInnerTextValue(htmlDocument, courseDetails.QualificationLevel, "td");
}
if (!string.IsNullOrWhiteSpace(courseDetails.Cost))
{
AssertTagInnerTextValue(htmlDocument, courseDetailsViewModel.PriceLabel, "th");
AssertTagInnerTextValue(htmlDocument, courseDetails.Cost, "td");
}
}
public void TestGetAgeRange(string ageRange, string expectedResult)
{
var courseVariantViewModel = new CourseDetailsViewModel {
AgeRange = ageRange
};
var result = courseVariantViewModel.GetAgeRange();
result.Should().Be(expectedResult);
}
public void TestGetQualification(string qualification, string expectedResult)
{
var courseVariantViewModel = new CourseDetailsViewModel {
Qualifications = qualification
};
var result = courseVariantViewModel.GetQualification();
result.Should().Be(expectedResult);
}
public void TestGetRoute(string route, string expectedResult)
{
var courseVariantViewModel = new CourseDetailsViewModel {
Route = route
};
var result = courseVariantViewModel.GetRoute();
result.Should().Be(expectedResult);
}
public void TestGetStudyMode(string studyMode, string expectedResult)
{
var courseVariantViewModel = new CourseDetailsViewModel {
StudyMode = studyMode
};
var result = courseVariantViewModel.GetStudyMode();
result.Should().Be(expectedResult);
}
public CourseDetails(ObservableCollection <Course> viewModelCourses, MainWindowViewModel mainWindowViewModel)
{
_mainWindowViewModel = mainWindowViewModel;
_adding = true;
_courses = viewModelCourses;
_viewModel = new CourseDetailsViewModel();
DataContext = _viewModel;
InitializeComponent();
}
public void GetQualification_should_be_empty(string input)
{
var param = new CourseDetailsViewModel {
Qualifications = input
};
var result = param.GetQualification();
Assert.IsTrue(result == IncorrectResult);
}
// GET: Course/Details/5
public ActionResult Details(int id)
{
var model = new CourseDetailsViewModel();
var repository = new CourseRepository(context);
var includes = new Expression <Func <Course, object> >[] { x => x.Topics };
var entity = repository.QueryIncluding(x => x.Id == id, includes).SingleOrDefault();
model = MapperHelper.Map <CourseDetailsViewModel>(entity);
return(View(model));
}
public void GetAgeRange_should_be_empty(string input)
{
var param = new CourseDetailsViewModel {
AgeRange = input
};
var result = param.GetAgeRange();
Assert.IsTrue(result == IncorrectResult);
}
