public async Task StudentsController_Post_PostGrade_Success()
{
ServiceResponse <CourseGrade> response = new ServiceResponse <CourseGrade>
{
Data = new CourseGrade {
gradeId = 1, courseId = 2032, grade = 4
},
Success = true,
Message = $"One of several failures occured inside studentsService.PostGrade"
};
CourseGrade grade = new CourseGrade {
courseId = 2032, studentId = 2
};
_mockStudentsService.Setup(service => service.PostGrade(grade)).Returns(Task.Run(() => { return(response); }));
// Act
var result = await _controller.PostGrade(grade) as ActionResult <CourseGrade>;
CourseGrade newGrade = ((Microsoft.AspNetCore.Mvc.ObjectResult)result.Result).Value as CourseGrade;
// Assert
Assert.IsType <CreatedAtActionResult>(result.Result);
Assert.True(newGrade != null);
}
/// <summary>
/// Create a new CourseGrade object.
/// </summary>
/// <param name="enrollmentID">Initial value of EnrollmentID.</param>
public static CourseGrade CreateCourseGrade(int enrollmentID)
{
CourseGrade courseGrade = new CourseGrade();
courseGrade.EnrollmentID = enrollmentID;
return(courseGrade);
}
protected void Page_Load(object sender, EventArgs e)
{
if (!(Session["user"] is Student))
{
Response.Redirect("login.aspx");
}
Master.TitelLabelText = "Karakterer";
Student student = (Student)Session["user"];
List <CourseGrade> courseGrades = CourseGrade.GetByConditions("StudentID=" + student.ID);
int gradeSum = 0;
foreach (CourseGrade grade in courseGrades)
{
gradeSum += Convert.ToInt32(grade.Grade);
TableRow gradeRow = new TableRow();
gradeRow.Cells.Add(new TableCell {
Text = grade.Course.Name
});
gradeRow.Cells.Add(new TableCell {
Text = grade.Grade
});
GradesTable.Rows.Add(gradeRow);
if (grade.Comment == string.Empty)
{
continue;
}
TableRow commentRow = new TableRow();
commentRow.Cells.Add(new TableCell {
Text = grade.Course.Name
});
commentRow.Cells.Add(new TableCell {
Text = grade.Comment
});
CommentsTable.Rows.Add(commentRow);
}
if (courseGrades.Count > 0) // Avoid DivideByZero
{
TableRow averageRow = new TableRow();
TableCell textCell = new TableCell
{
Text = "Gennemsnit",
CssClass = "average-grade"
};
averageRow.Cells.Add(textCell);
TableCell averageCell = new TableCell {
Text = ((double)gradeSum / (double)courseGrades.Count).ToString()
};
averageCell.Attributes.Add("class", "average-grade");
averageRow.Cells.Add(averageCell);
GradesTable.Rows.Add(averageRow);
}
if (GradesTable.Rows.Count == 1)
{
AddAlertRow(GradesTable, "Du har ikke fået nogen kursus karakterer");
}
if (CommentsTable.Rows.Count == 1)
{
AddAlertRow(CommentsTable, "Du har ikke fået nogen karakter kommentarer");
}
}
public void RemoverRemoveCourse_ValidParameters_CourseRemoved()
{
// Arrange
Creator.CreateCourse(Instances.Name, Instances.Description);
Course course = Course.GetByID(1);
Creator.CreateStudent(Instances.Name, Instances.Username, Instances.Password);
Student student = Student.GetByID(2);
course.AddStudent(student);
Creator.CreateTeacher(Instances.Name, Instances.Username, Instances.Password);
Teacher teacher = Teacher.GetByID(3);
course.AddTeacher(teacher);
Creator.CreateLesson(course, Instances.Description, Instances.Online,
Instances.Date, Instances.Rooms, Instances.Filepaths);
Creator.CreateAssignmentDescription(course, Instances.Description, Instances.Date, Instances.Filepaths);
Creator.CreateCourseGrade(course, student, Instances.Grade, Instances.Comment);
// Act
Remover.RemoveCourse(course);
// Assert
Assert.AreEqual(0, Course.GetAll().Count);
Assert.AreEqual(0, student.Courses.Count);
Assert.AreEqual(0, teacher.Courses.Count);
Assert.AreEqual(0, Lesson.GetAll().Count);
Assert.AreEqual(0, AssignmentDescription.GetAll().Count);
Assert.AreEqual(0, CourseGrade.GetAll().Count);
}
public async Task <IActionResult> Edit(int id, [Bind("CourseGradeId,StudentId,CourseId,ExamGrade,LabGrade,BonusPoints,IsGraduated")] CourseGrade courseGrade)
{
if (id != courseGrade.CourseGradeId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
courseGradeService.UpdateCourseGrade(courseGrade);
}
catch (DbUpdateConcurrencyException)
{
if (!courseGradeService.CourseGradeExists(courseGrade.CourseGradeId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["CourseId"] = new SelectList(courseGradeService.GetAllCourses(), "CourseId", "Name");
ViewData["StudentId"] = new SelectList(courseGradeService.GetAllStudents(), "StudentId", "FirstName");
return(View(courseGrade));
}
private int FindCourseId(string course, string grade)
{
int courseGradeId = 0;
int courseId = int.Parse(course);
var courseGrade = (from cg in _dataContext.CourseGrade where (cg.CourseId == courseId && cg.Grade == grade) select cg).ToList();
if (courseGrade.Count > 0)
{
courseGradeId = courseGrade[0].Id;
}
else
{
var cg = new CourseGrade()
{
CourseId = int.Parse(course), Grade = grade
};
_dataContext.CourseGrade.Add(cg);
_dataContext.SaveChanges();
courseGradeId = cg.Id;
}
return(courseGradeId);
}
private bool ValidateCourseGrade(CourseGrade courseGrade, ref string errorMessage)
{
_log.LogDebug("StudentService.ValidateCourseGrade called");
if (!StudentExists(courseGrade.studentId))
{
errorMessage = $"Student Id = {courseGrade.studentId} does not exist";
_log.LogDebug($"StudentService.Validation: {errorMessage}");
return(false);
}
if (!CourseExists(courseGrade.courseId))
{
errorMessage += $"Course Id = {courseGrade.courseId} does not exist";
_log.LogDebug($"StudentService.Validation: {errorMessage}");
return(false);
}
//
// Note: I have a constaint on the grade column which will prevent inserts not meeting the null or range of 0 - 4
// However, I prefer not to hit the database if are not in a valid state because the SQL constraint error
// may not provide enough information (other than the name of the constraint violated).
// I also have Model validation through Data Annotations on the models exposed to the world.
// This is just bullet proofing in case the user gets around Model validation somehow
//
if (courseGrade.grade != null)
{
bool validRange = (courseGrade.grade >= 0 && courseGrade.grade <= 4);
if (!validRange)
{
errorMessage = $"Invalid Grade Value {courseGrade.grade}: A value of null or between 0 and 4 is required.\r\n";
_log.LogDebug($"StudentService.Validation: {errorMessage}");
return(false);
}
}
//
// We cannot have more than one grade per course per student.
//
var existingGrade = _uow.Context.StudentGrade.Where(e => e.CourseId == courseGrade.courseId && e.StudentId == courseGrade.studentId).FirstOrDefault();
if (existingGrade != null)
{
errorMessage = $"The student already has a grade entered for CourseId = {courseGrade.courseId}. Did you meant to use PUT/Update?";
_log.LogDebug($"StudentService.Validation: {errorMessage}");
return(false);
}
return(true);
}
/// <summary>
/// Create a new CourseGrade object.
/// </summary>
/// <param name="enrollmentID">Initial value of EnrollmentID.</param>
/// <param name="courseID">Initial value of CourseID.</param>
/// <param name="studentID">Initial value of StudentID.</param>
public static CourseGrade CreateCourseGrade(int enrollmentID, int courseID, int studentID)
{
CourseGrade courseGrade = new CourseGrade();
courseGrade.EnrollmentID = enrollmentID;
courseGrade.CourseID = courseID;
courseGrade.StudentID = studentID;
return(courseGrade);
}
public async Task <IActionResult> Create([Bind("CourseGradeId,StudentId,CourseId,ExamGrade,LabGrade,BonusPoints,IsGraduated")] CourseGrade courseGrade)
{
if (ModelState.IsValid)
{
courseGradeService.Create(courseGrade);
return(RedirectToAction(nameof(Index)));
}
ViewData["CourseId"] = new SelectList(courseGradeService.GetAllCourses(), "CourseId", "Name");
ViewData["StudentId"] = new SelectList(courseGradeService.GetAllStudents(), "StudentId", "FirstName");
return(View(courseGrade));
}
public IActionResult AddGrade(CourseGrade courseGrade)
{
if (!ModelState.IsValid)
{
return(View());
}
courseGrade.CreatedDate = DateTime.Now;
_db.Grades.Add(courseGrade);
_db.SaveChanges();
return(RedirectToAction(nameof(StudentController.Index), "Student"));
}
/// <summary>
/// This event handler handles the RowEdited event of the DataGrid control
/// It updates the edited Grade via an async REST call to ADO.NET Data Service.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void mainDataGrid_RowEditEnded(object sender, DataGridRowEditEndedEventArgs e)
{
ScoreCardForSchoolLinqToEntities s = e.Row.DataContext as ScoreCardForSchoolLinqToEntities;
if (s != null)
{
CourseGrade recordforupdate = s.CourseGrade;
_entities.UpdateObject(recordforupdate);
_entities.BeginSaveChanges(SaveChangesOptions.ReplaceOnUpdate,
OnChangesSaved, _entities);
}
}
/// <summary>
/// This event handler handles the Click event of the Delete Button control
/// It deletes the record that is on the same row of the Delete Button,
/// via an async REST call to ADO.NET Data Service.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void DeleteButton_Click(object sender, RoutedEventArgs e)
{
Button b = (Button)sender;
ScoreCardForSchoolLinqToSQL s = b.DataContext as ScoreCardForSchoolLinqToSQL;
if (s != null)
{
CourseGrade recordfordelete = s.CourseGrade;
_context.DeleteObject(recordfordelete);
_context.BeginSaveChanges(SaveChangesOptions.None,
OnChangesSaved, _context);
}
}
public ActionResult Edit_CourseGrade(CourseGrade ob)
{
if (ModelState.IsValid)
{
CourseGradeBL.Update(ob);
return(RedirectToAction("course_Grade"));
}
else
{
return(View());
}
}
public async Task <ActionResult <CourseGrade> > PostGrade(CourseGrade courseGrade)
{
ServiceResponse <CourseGrade> response = await _studentsService.PostGrade(courseGrade);
if (!response.Success)
{
// We were unable to create a new StudentGrade record.
return(BadRequest(new BadRequestResponse(response.Message)));
}
CourseGrade newCourseGrade = response.Data as CourseGrade;
return(CreatedAtAction("PostGrade", newCourseGrade));
}
public void CourseGradeNew_ValidParameters_ValuesMatch()
{
// Arrange
var course = Course.New(Instances.Name, Instances.Description);
var student = Student.New(Instances.Name, Instances.Username, Instances.Password);
// Act
var courseGrade = CourseGrade.New(course, student, Instances.Grade, Instances.Comment);
// Assert
Assert.AreEqual(course.ID, courseGrade.Course.ID);
Assert.AreEqual(student.ID, courseGrade.Student.ID);
Assert.AreEqual(Instances.Grade, courseGrade.Grade);
Assert.AreEqual(Instances.Comment, courseGrade.Comment);
}
/// <summary>
/// PostGrade creates a new Course grade for a given student.
/// </summary>
/// <param name="courseGrade"></param>
/// <returns>A Tuple containing CourseGrade and a error message string</returns>
public async Task <ServiceResponse <CourseGrade> > PostGrade(CourseGrade courseGrade)
{
_log.LogDebug("StudentService.PostGrade called");
string errorMessage = string.Empty;
if (!ValidateCourseGrade(courseGrade, ref errorMessage))
{
_log.LogError($"StudentService.PostGrade: {errorMessage??"Validation Error"}");
//
// Validation failed. There was a validation issue preventing this post.
//
return(new ServiceResponse <CourseGrade>
{
Success = false,
Message = errorMessage,
Data = courseGrade // returning the value passed into us
});
}
_log.LogDebug("StudentService.PostGrade: Adding new CourseGrade");
StudentGrade newGrade = new StudentGrade
{
StudentId = courseGrade.studentId,
CourseId = courseGrade.courseId,
Grade = courseGrade.grade
};
//
// This is interesting: GetRepository lazy load/adds a StudentGrade repository here when requested.
// This is something new I am playing with in this code challenge.
_uow.GetRepository <StudentGrade>().Add(newGrade);
await Task.Run(() => _uow.Commit());
CourseGrade newCourseGrade = _mapper.Map <CourseGrade>(newGrade);
_log.LogDebug($"StudentService.PostGrade: CourseGrade.gradeId = {newCourseGrade.gradeId} Added Successfully ");
return(new ServiceResponse <CourseGrade>
{
Success = true,
Message = errorMessage,
Data = newCourseGrade
});
}
public void RemoverRemoveCourseGrade_ValidParameters_CourseGradeRemoved()
{
// Arrange
Creator.CreateCourse(Instances.Name, Instances.Description);
Course course = Course.GetByID(1);
Creator.CreateCourseGrade(course, Instances.Student, Instances.Grade, Instances.Comment);
CourseGrade courseGrade = CourseGrade.GetByID(1);
// Act
Remover.RemoveCourseGrade(courseGrade);
// Assert
Assert.AreEqual(0, course.CourseGrades.Count);
Assert.AreEqual(0, CourseGrade.GetAll().Count);
}
public CourseGrade GetStudentGrade(Guid courseId, Student student)
{
CourseGrade courseGrade = null;
var selectedCourse = dbContext.Courses
.Where(course => course.Id == courseId)
.SingleOrDefault();
if (selectedCourse != null)
{
courseGrade = selectedCourse.CourseGrades
.Where(grade => grade.Student.Id == student.Id)
.SingleOrDefault();
}
return(courseGrade);
}
public void RemoverRemoveCourseGrade_ValidParameters_CourseGradeRemoved()
{
// Arrange
var courseGrade = CourseGrade.New(Instances.Course, Instances.Student, Instances.Grade, Instances.Comment);
var courseGradeid = courseGrade.ID;
// Act
courseGrade.Remove();
// Assert
try
{
CourseGrade.GetByID(courseGradeid);
Assert.Fail();
}
catch (InvalidIDException) { }
}
//public Nullable<double> CalculateGrade(Course course, CourseGrade grade)
public double?CalculateGrade(Course course, CourseGrade grade)
{
List <ModuleGrade> mods = grade.Modules;
//Let's just do something basic as a token effort given the time!
/*courseCache = courseIO.LoadData();
* return courseCache;*/
List <AssignmentGrade> allAGs = new List <AssignmentGrade>();
//IEnumerable filteredAGs;
if (mods != null)
{
mods.ForEach((mod) => {
List <AssignmentGrade> agList = mod.Assignments;
if (agList != null)
{
allAGs.AddRange(agList);
}
});
}
IEnumerable <AssignmentGrade> filteredAGs = allAGs.Where((ag) => {
return(ag.Score != null);
});
Nullable <double> totalScore;
if (filteredAGs.Count() > 0)
{
totalScore = filteredAGs.Average((ag) => {
return(ag.Score);
});
//return totalScore;
}
else
{
totalScore = null;
}
return(totalScore);
}
public ActionResult Index()
{
//Test
Session["user"] = Student.GetByConditions("name='Iver Clausen'").Single();
//Actual
Person person = (Person)Session["user"];
if (person == null)
{
return(RedirectToAction("Index", "Login"));
}
if (person is Student)
{
List <CourseGrade> grades = CourseGrade.GetByConditions("StudentID=" + person.ID);
return(View(new CourseGradeViewModel {
Grades = grades
}));
}
return(RedirectToAction("Index", "News"));
}
public ActionResult Index(int id)
{
//Test
Session["user"] = Student.GetByConditions("name='Iver Clausen'").Single();
//Actual
Person person = (Person)Session["user"];
CourseGrade currentGrade;
if (person == null)
{
try
{
currentGrade = CourseGrade.GetByID(Convert.ToUInt32(id));
}
catch (InvalidIDException)
{
return(RedirectToAction("Index", "Login"));
}
}
return(RedirectToAction("Index", "News"));
}
public CourseGradeEstimatorInit()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Course courseData = dataLayer.LoadCourseData();
CourseGrade gradeData = dataLayer.LoadGradeData();
Routings initRoute = courseData != null ? Routings.CourseSummary: Routings.Start;
DataDTO <Course, Course, CourseGrade> data = null;
if (courseData != null)
{
data = new DataDTO <Course, Course, CourseGrade> {
Data = courseData, Grade = gradeData
};
}
router.navTo(initRoute, data);
Application.Run(router);
}
public async Task StudentsController_Post_PostGrade_Failure()
{
CourseGrade grade = new CourseGrade {
gradeId = 1, courseId = 2032, studentId = 2
};
ServiceResponse <CourseGrade> response = new ServiceResponse <CourseGrade>
{
Data = grade,
Success = false, // we failed to post the new grade for some reason
Message = $"One of several failures occured inside studentsService.PostGrade"
};
_mockStudentsService.Setup(service => service.PostGrade(grade)).Returns(Task.Run(() => { return(response); }));
// Act
var result = await _controller.PostGrade(grade) as ActionResult <CourseGrade>;
// Assert
Assert.IsType <BadRequestObjectResult>(result.Result);
// Validate that it is sending School.API.Utility.NotFoundResponse
Assert.IsType <School.API.Utility.BadRequestResponse>(((Microsoft.AspNetCore.Mvc.ObjectResult)result.Result).Value);
}
public void CreateCourse(Course course)
{
var courseExists = (from c in _dataContext.Course.Where(c => c.Subject == course.Subject) select c).ToList();
//is new course
if (courseExists.Count == 0)
{
AddCourse(course);
AddCourseGrade(new CourseGrade {
CourseId = course.Id, Grade = course.Grade
});
return;
}
var existingCourseId = courseExists[0].Id;
try
{
var courseGradeExists =
(from cg in
_dataContext.CourseGrade.Where(cg => cg.CourseId == existingCourseId && cg.Grade == course.Grade)
select cg).ToList();
//is new grade for existing course
if (courseGradeExists.Count == 0)
{
var courseGrade = new CourseGrade {
CourseId = existingCourseId, Grade = course.Grade
};
AddCourseGrade(courseGrade);
}
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// There are no comments for CourseGrades in the schema.
/// </summary>
public void AddToCourseGrades(CourseGrade courseGrade)
{
base.AddObject("CourseGrades", courseGrade);
}
/// <summary>
/// Create a new CourseGrade object.
/// </summary>
/// <param name="enrollmentID">Initial value of EnrollmentID.</param>
/// <param name="courseID">Initial value of CourseID.</param>
/// <param name="studentID">Initial value of StudentID.</param>
public static CourseGrade CreateCourseGrade(int enrollmentID, int courseID, int studentID)
{
CourseGrade courseGrade = new CourseGrade();
courseGrade.EnrollmentID = enrollmentID;
courseGrade.CourseID = courseID;
courseGrade.StudentID = studentID;
return courseGrade;
}
/// <summary>
/// Create a new CourseGrade object.
/// </summary>
/// <param name="enrollmentID">Initial value of EnrollmentID.</param>
public static CourseGrade CreateCourseGrade(int enrollmentID)
{
CourseGrade courseGrade = new CourseGrade();
courseGrade.EnrollmentID = enrollmentID;
return courseGrade;
}
public void RemoveCourseGrade(CourseGrade courseGrade)
{
_courseGradeRepository.DeleteCourseGrade(courseGrade);
}
public void UpdateCourseGrade(CourseGrade courseGrade)
{
_courseGradeRepository.UpdateCourseGrade(courseGrade);
}
public void AddCourseGrade(CourseGrade courseGrade)
{
_courseGradeRepository.InsertCourseGrade(courseGrade);
}
public void UpdateCourseGrade(CourseGrade courseGrade)
{
_repo.CourseGrade.Update(courseGrade);
_repo.Save();
}
public void Create(CourseGrade courseGrade)
{
_repo.CourseGrade.Create(courseGrade);
_repo.Save();
}
