public HomeTaskAssessment GetHomeTaskAssessmentById(int assessmentId)
{
HomeTaskAssessment homeTaskAssessment = new HomeTaskAssessment();
using (SqlConnection connection = GetConnection())
{
SqlCommand sqlCommand = new SqlCommand(
$@"
SELECT [Id]
,[IsComplete]
,[Date]
,[StudentId]
,[HomeTaskId]
FROM [dbo].[HomeTaskAssessment]
where Id = {assessmentId}", connection);
using (var reader = sqlCommand.ExecuteReader())
{
while (reader.Read())
{
homeTaskAssessment.Id = reader.GetInt32(0);
homeTaskAssessment.IsComplete = reader.GetBoolean(1);
homeTaskAssessment.Date = reader.GetDateTime(2);
int studentId = reader.GetInt32(3);
int homeTaskId = reader.GetInt32(4);
homeTaskAssessment.Student = this.GetStudentById(studentId, false);
homeTaskAssessment.HomeTask = GetHomeTaskById(homeTaskId, false);
}
}
}
return(homeTaskAssessment);
}
public void DeleteStudent_RemovesStudent_WhenStudentExist()
{
//Arrange
HomeTaskAssessment homeTaskAssessment = new HomeTaskAssessment()
{
Id = HomeTaskAssessmentId
};
Student student = GetDefaultStudent();
student.HomeTaskAssessments = new List <HomeTaskAssessment>()
{
homeTaskAssessment
};
var studentRepository = Substitute.For <IRepository <Student> >();
studentRepository.GetAll().Returns(new List <Student>());
studentRepository.GetById(student.Id).Returns(student);
IRepository <HomeTaskAssessment> homeTaskAssessmentRepository = Substitute.For <IRepository <HomeTaskAssessment> >();
StudentService studentService = new StudentService(studentRepository, homeTaskAssessmentRepository);
//Act
studentService.DeleteStudent(student.Id);
//Assert
homeTaskAssessmentRepository.Received(Quantity.Exactly(1)).Remove(HomeTaskAssessmentId);
studentRepository.Received(Quantity.Exactly(1)).Remove(student.Id);
}
private List <HomeTaskAssessment> GetHomeTaskAssessments(int homeTaskId)
{
List <HomeTaskAssessment> result = new List <HomeTaskAssessment>();
using (SqlConnection connection = GetConnection())
{
SqlCommand sqlCommand = new SqlCommand(
$@"
SELECT [Id]
,[IsComplete]
,[Date]
FROM [dbo].[HomeTaskAssessment]
where HomeTaskId = {homeTaskId}", connection);
using var reader = sqlCommand.ExecuteReader();
while (reader.Read())
{
HomeTaskAssessment homeTaskAssessment = new HomeTaskAssessment();
homeTaskAssessment.Id = reader.GetInt32(0);
homeTaskAssessment.IsComplete = reader.GetBoolean(1);
homeTaskAssessment.Date = reader.GetDateTime(2);
result.Add(homeTaskAssessment);
}
}
return(result);
}
public static List <HomeTaskAssessment> GetAllHomeTasksAssessments()
{
using (SqlConnection connection = GetConnection())
{
SqlCommand sqlCommand = new SqlCommand(@"SELECT * FROM HomeTaskAssessment",
connection);
List <HomeTaskAssessment> homeTaskAssessments = new List <HomeTaskAssessment>();
using (var reader = sqlCommand.ExecuteReader())
{
while (reader.Read())
{
HomeTaskAssessment homeTaskAssessment = new HomeTaskAssessment
{
Id = reader.GetInt32(0),
IsComplete = reader.GetBoolean(1),
Date = reader.GetDateTime(2),
};
int studentId = reader.GetInt32(3);
int homeTaskId = reader.GetInt32(4);
homeTaskAssessment.Student = GetStudentById(studentId);
homeTaskAssessment.Hometask = GetHometaskById(homeTaskId);
homeTaskAssessments.Add(homeTaskAssessment);
}
}
return(homeTaskAssessments);
}
}
private List <HomeTaskAssessment> GetHomeTaskAssessmentsByStudentId(int studentId)
{
List <HomeTaskAssessment> result = new List <HomeTaskAssessment>();
using (SqlConnection connection = GetConnection())
{
SqlCommand sqlCommand = new SqlCommand(
$@"
SELECT [Id]
,[IsComplete]
,[Date]
,[StudentId]
,[HomeTaskId]
FROM [dbo].[HomeTaskAssessment]
where StudentId = {studentId}", connection);
using (var reader = sqlCommand.ExecuteReader())
{
while (reader.Read())
{
HomeTaskAssessment homeTaskAssessment = new HomeTaskAssessment();
homeTaskAssessment.Id = reader.GetInt32(0);
homeTaskAssessment.IsComplete = reader.GetBoolean(1);
homeTaskAssessment.Date = reader.GetDateTime(2);
//int homeTaskId = reader.GetInt32(4);
//homeTaskAssessment.Student = this.GetStudentById(studentId);
//homeTaskAssessment.HomeTask = GetHomeTaskById(homeTaskId);
result.Add(homeTaskAssessment);
}
}
}
return(result);
}
public void UpdateHomeTaskAssessment(HomeTaskAssessment homeTaskAssessment)
{
var t = context.HomeTaskAssessment.Where(p => p.Id == homeTaskAssessment.Id).FirstOrDefault();
t.IsComplete = homeTaskAssessment.IsComplete;
context.HomeTaskAssessment.Update(t);
SaveChanges();
}
public void DeleteHomeTaskAssessment(HomeTaskAssessment homeTaskAssessment)
{
using (AcademyContext academyDb = new AcademyContext(options))
{
academyDb.HomeTaskAssessment.Remove(homeTaskAssessment);
academyDb.SaveChanges();
}
}
public IActionResult Edit(HomeTaskAssessment assessment)
{
repository.UpdateHomeTaskAssessments(new List <HomeTaskAssessment>()
{
assessment
});
return(RedirectToAction("StudentAssessments", new { studentId = assessment.Student.Id }));
}
public void AssignStudentsToCourse(int courseId, IEnumerable <int> assignedStudentsIds)
{
using (AcademyContext academyDb = new AcademyContext(options))
{
using (var transaction = academyDb.Database.BeginTransaction())
{
List <int> previouslyAssignedstudentsIds = academyDb.StudentCourse.Where(sc => sc.CourseId == courseId).Select(sc => sc.StudentId).ToList();
List <int> disassignedStudentsIds = previouslyAssignedstudentsIds.Except(assignedStudentsIds).ToList();
List <int> newAssignedStudentsIds = assignedStudentsIds.Except(previouslyAssignedstudentsIds).ToList();
// delete disassigned students assessments
foreach (var disStId in disassignedStudentsIds)
{
// todo remove range not necessary
academyDb.HomeTaskAssessment.RemoveRange(
academyDb.HomeTaskAssessment.Where(ha => ha.StudentId == disStId));
}
// disassigne disassigned students
foreach (var disStId in disassignedStudentsIds)
{
// todo remove range not necessary
academyDb.StudentCourse.RemoveRange(
academyDb.StudentCourse.Where(sc => sc.StudentId == disStId));
}
// assign new assigned students
foreach (var asi in newAssignedStudentsIds)
{
academyDb.StudentCourse.Add(new StudentCourse()
{
StudentId = asi, CourseId = courseId
});
}
// create assessments for new assigned students
List <int> courseHometasksIds = academyDb.HomeTask.Where(h => h.CourseId == courseId).Select(h => h.Id).ToList();
foreach (var studentId in newAssignedStudentsIds)
{
foreach (var hometaskId in courseHometasksIds)
{
HomeTaskAssessment assessment = new HomeTaskAssessment()
{
IsComplete = false,
Date = DateTime.Now,
HomeTaskId = hometaskId,
StudentId = studentId
};
academyDb.HomeTaskAssessment.Add(assessment);
}
}
academyDb.SaveChanges();
transaction.Commit();
}
}
}
public virtual bool DeleteHomeTaskAssessment(HomeTaskAssessment homeTaskAssessment)
{
if (academyRepository == null)
{
return(false);
}
academyRepository.DeleteHomeTaskAssessment(homeTaskAssessment);
return(true);
}
public void DeleteHomeTaskAssessment(int id)
{
using (AcademyContext academyDb = new AcademyContext(options))
{
HomeTaskAssessment homeTaskAssessment = GetHomeTaskAssessment(id);
DeleteHomeTaskAssessment(homeTaskAssessment);
academyDb.SaveChanges();
}
}
public virtual HomeTaskAssessment GetHomeTaskAssessment(int id)
{
if (academyRepository == null)
{
return(null);
}
HomeTaskAssessment homeTaskAssessment = academyRepository.GetHomeTaskAssessment(id);
return(homeTaskAssessment);
}
public IActionResult Edit(int id)
{
HomeTaskAssessment assessment = homeTaskAssessmentService.GetHomeTaskAssessment(id);
if (assessment == null)
{
return(NotFound());
}
return(View(assessment));
}
public static HomeTaskAssessmentDto FromModel(HomeTaskAssessment homeTaskAssessment)
{
return(new HomeTaskAssessmentDto()
{
Date = homeTaskAssessment.Date,
StudentId = homeTaskAssessment.StudentId,
IsComplete = homeTaskAssessment.IsComplete,
Id = homeTaskAssessment.Id,
HomeTaskId = homeTaskAssessment.HomeTaskId
});
}
private static void ImportHomeTaskAssesments(HomeTask homeTask, IEnumerable <XElement> homeTaskAssessmentElements)
{
foreach (var homeTaskAssessmentElement in homeTaskAssessmentElements)
{
HomeTaskAssessment homeTaskAssessment = new HomeTaskAssessment();
homeTaskAssessment.Id = int.Parse(homeTaskAssessmentElement.Element("Id").Value);
homeTaskAssessment.IsComplete = bool.Parse(homeTaskAssessmentElement.Element("IsComplete").Value);
homeTaskAssessment.Date = DateTime.Parse(homeTaskAssessmentElement.Element("Date").Value);
homeTask.HomeTaskAssessments.Add(homeTaskAssessment);
}
}
public void UpdateHomeTaskAssessmentByTask(HomeTaskAssessment homeTaskAssessment)
{
using (SqlConnection connection = GetConnection())
{
SqlCommand sqlCommand = new SqlCommand(@"
UPDATE [dbo].[HomeTaskAssessment]
SET [IsComplete] = @IsComplete,
[Date] = @Date
WHERE Id = @Id", connection);
sqlCommand.Parameters.AddWithValue("@IsComplete", homeTaskAssessment.IsComplete);
sqlCommand.Parameters.AddWithValue("@Date", homeTaskAssessment.Date);
sqlCommand.Parameters.AddWithValue("@Id", homeTaskAssessment.Id);
sqlCommand.ExecuteNonQuery();
}
}
public void Edit_Post_RedirectToStudentAssessments()
{
// Arrange
HomeTaskAssessment assessment = new HomeTaskAssessment();
var homeTaskAssessmentSericeMock = Substitute.For <HomeTaskAssessmentService>();
homeTaskAssessmentSericeMock.UpdateHomeTaskAssessment(assessment).Returns(true);
var controller = new HomeTaskAssessmentController(homeTaskAssessmentSericeMock, null);
// Act
var result = controller.Edit(assessment);
// Assert
var redirectToActionResult = Assert.IsType <RedirectToActionResult>(result);
Assert.Null(redirectToActionResult.ControllerName);
Assert.Equal("StudentAssessments", redirectToActionResult.ActionName);
}
public IActionResult AssignStudents(CourseStudentsAssignmentViewModel model)
{
var assignedStudentsId = model.StudentsList.Where(a => a.IsAssigned)
.Select(s => s.Student.Id);
repository.SetStudentsToCourse(model.Course.Id, assignedStudentsId);
var courseHometasksIds = repository.GetCourse(model.Course.Id).HomeTasks
.Select(h => h.Id);
foreach (var studentId in assignedStudentsId)
{
var studentHometaskIds = repository.GetStudentById(studentId, true).HomeTaskAssessments
.Select(a => a.HomeTask.Id);
var missingHometasksId = courseHometasksIds.Except(studentHometaskIds);
List <HomeTaskAssessment> assessments = new List <HomeTaskAssessment>();
foreach (var hometaskId in missingHometasksId)
{
HomeTaskAssessment assessment = new HomeTaskAssessment()
{
IsComplete = false,
Date = DateTime.Now,
HomeTask = new HomeTask()
{
Id = hometaskId
},
Student = new Student()
{
Id = studentId
}
};
assessments.Add(assessment);
}
repository.CreateHomeTaskAssessments(assessments);
}
return(RedirectToAction("Courses"));
}
public HomeTaskAssessment GetHomeTaskAssessmentById(int id, bool mark)
{
HomeTaskAssessment result = new HomeTaskAssessment();
using (SqlConnection connection = GetConnection())
{
SqlCommand sqlCommand = new SqlCommand(
$@"
SELECT [Id]
,[IsComplete]
,[Date]
,[StudentId]
,[HomeTaskId]
FROM [dbo].[HomeTaskAssessment]
where Id = {id}", connection);
using (var reader = sqlCommand.ExecuteReader())
{
reader.Read();
result.Id = reader.GetInt32(0);
result.IsComplete = mark;
result.Date = reader.GetDateTime(2);
Student student = new Student()
{
Id = reader.GetInt32(3)
};
result.Student = student;
var hometask = new HomeTask()
{
Id = reader.GetInt32(4)
};
result.HomeTask = hometask;
}
}
return(result);
}
public void DeleteCourse_RemovesCourse_WhenCourseExist()
{
//Arrange
HomeTaskAssessment homeTaskAssessment = new HomeTaskAssessment()
{
Id = HomeTaskAssessmentId
};
HomeTask homeTask = new HomeTask()
{
HomeTaskAssessments = new List <HomeTaskAssessment>()
{
homeTaskAssessment
},
Id = HomeTaskId
};
Course course = GetDefaultCourse();
course.HomeTasks = new List <HomeTask>()
{
homeTask
};
var courseRepository = Substitute.For <IRepository <Course> >();
courseRepository.GetById(course.Id).Returns(course);
IRepository <HomeTask> homeTaskRepository = Substitute.For <IRepository <HomeTask> >();
IRepository <HomeTaskAssessment> homeTaskAssessmentRepository = Substitute.For <IRepository <HomeTaskAssessment> >();
CourseService courseService = new CourseService(courseRepository, null, homeTaskRepository, homeTaskAssessmentRepository);
//Act
courseService.DeleteCourse(course.Id);
//Assert
courseRepository.Received(Quantity.Exactly(1)).Remove(course.Id);
homeTaskRepository.Received(Quantity.Exactly(1)).Remove(HomeTaskId);
homeTaskAssessmentRepository.Received(Quantity.Exactly(1)).Remove(HomeTaskAssessmentId);
}
static void Main(string[] args)
{
SetConnectionString();
IRepository <Course> courseRepository = GetCourseRepository();
Course newCourse = new Course()
{
StartDate = DateTime.Now, EndDate = DateTime.Now, PassCredits = 500
};
var course = courseRepository.Create(newCourse);
course.PassCredits = 1000;
courseRepository.Update(course);
IRepository <Student> studentRepository = GetStudentRepository();
Student newStudent = new Student()
{
BirthDate = DateTime.Now,
Email = "Test",
GitHubLink = "Test",
Name = "test",
PhoneNumber = "000"
};
var insertedStudent = studentRepository.Create(newStudent);
//Update
insertedStudent.Notes += "; Is employed";
insertedStudent.Courses.Add(course);
studentRepository.Update(insertedStudent);
var homeTaskRepository = GetHomeTaskRepository();
var homeTaskAssessmentRepository = GetHomeTaskAssessmentRepository();
HomeTask homeTask = new HomeTask()
{
Course = course,
CourseId = course.Id,
Date = DateTime.Now,
Title = "First By Program"
};
homeTask = homeTaskRepository.Create(homeTask);
HomeTaskAssessment homeTaskAssessment = new HomeTaskAssessment()
{
Date = DateTime.Now, StudentId = insertedStudent.Id, HomeTaskId = homeTask.Id
};
homeTaskAssessment = homeTaskAssessmentRepository.Create(homeTaskAssessment);
homeTask.Title += " Updated";
homeTask.HomeTaskAssessments.Add(homeTaskAssessment);
homeTaskAssessment.IsComplete = true;
homeTaskAssessmentRepository.Update(homeTaskAssessment);
homeTaskAssessment.Date = new DateTime(2020, 1, 1);
homeTaskRepository.Update(homeTask);
var result = homeTaskAssessmentRepository.GetById(homeTaskAssessment.Id);
var homeTaskResult = homeTaskRepository.GetById(homeTask.Id);
homeTaskAssessmentRepository.Remove(homeTaskAssessment.Id);
homeTaskRepository.Remove(homeTask.Id);
studentRepository.Remove(insertedStudent.Id);
courseRepository.Remove(course.Id);
}
public IActionResult Edit(HomeTaskAssessment assessment)
{
homeTaskAssessmentService.UpdateHomeTaskAssessment(assessment);
return(RedirectToAction("StudentAssessments", new { studentId = assessment.StudentId }));
}
public IActionResult Edit([FromRoute] int id)
{
HomeTaskAssessment assessment = repository.GetHomeTaskAssessmentById(id);
return(View(assessment));
}
