public IHttpActionResult UpdateCourse(Guid id, CourseServiceModel updatedCourse)
{
if (!this.ModelState.IsValid)
{
return(BadRequest(this.ModelState));
}
var oldCourse = this.GetCourseById(id);
oldCourse.Name = updatedCourse.Name;
oldCourse.Description = updatedCourse.Description;
foreach (var studentNames in updatedCourse.Students)
{
string[] names = studentNames.Split(' ');
oldCourse.Students.Add(new Student
{
FirstName = names[0],
LastName = names[1]
});
}
this.data.SaveChanges();
return(Ok(CourseServiceModel.ConvertFromCourse(oldCourse)));
}
public async Task CreateCourse(CourseServiceModel model, string id)
{
Course course = Mapper.Map <Course>(model);
course.TeacherId = id;
await this.context.Courses.AddAsync(course);
await this.context.SaveChangesAsync();
}
public IHttpActionResult RemoveCourse(Guid id)
{
var course = this.GetCourseById(id);
this.data.Courses.Delete(course);
this.data.SaveChanges();
return(Ok(CourseServiceModel.ConvertFromCourse(course)));
}
public static void AssertCourseServiceModel(CourseServiceModel expectedCourse, CourseServiceModel actualCourse)
{
Assert.NotNull(actualCourse);
Assert.Equal(expectedCourse.Name, actualCourse.Name);
Assert.Equal(expectedCourse.StartDate, actualCourse.StartDate);
Assert.Equal(expectedCourse.EndDate, actualCourse.EndDate);
Assert.Equal(expectedCourse.TrainerId, actualCourse.TrainerId);
Assert.Equal(expectedCourse.TrainerName, actualCourse.TrainerName);
}
public IHttpActionResult EnrollInCourse(int studentId, CourseServiceModel newCourse)
{
var student = this.GetStudentById(studentId);
var course = newCourse.ConvertToCourse();
student.Courses.Add(course);
this.data.SaveChanges();
return(Ok(StudentServiceModel.ConvertFromStudent(student)));
}
public async Task UpdateCourse(CourseServiceModel model)
{
var course = this.context
.Courses
.FirstOrDefault(s => s.Id == model.Id);
course.Name = model.Name;
course.Description = model.Description;
course.StartDate = model.StartDate;
course.EndDate = model.EndDate;
await this.context.SaveChangesAsync();
}
public async Task DeleteCourse(CourseServiceModel model)
{
var course = await this.context
.Courses
.FirstOrDefaultAsync(c => c.Id == model.Id);
if (course != null)
{
this.context.Courses.Remove(course);
await this.context.SaveChangesAsync();
}
}
public IHttpActionResult AddStudent(Guid courseId, StudentServiceModel studentModel)
{
if (!this.ModelState.IsValid)
{
return(BadRequest(this.ModelState));
}
var course = this.GetCourseById(courseId);
course.Students.Add(studentModel.ConverToStudent());
this.data.SaveChanges();
return(Ok(CourseServiceModel.ConvertFromCourse(course)));
}
public IHttpActionResult AddCourse(CourseServiceModel newCourse)
{
if (!this.ModelState.IsValid)
{
return(BadRequest(this.ModelState));
}
Course course = newCourse.ConvertToCourse();
this.data.Courses.Add(course);
this.data.SaveChanges();
newCourse.Id = course.Id;
return(Ok(newCourse));
}
private void AssertCourseServiceModel(Course expected, CourseServiceModel result)
{
Assert.Equal(expected.Id, result.Id);
Assert.Equal(expected.Name, result.Name);
Assert.Equal(expected.StartDate, result.StartDate);
Assert.Equal(expected.EndDate, result.EndDate);
Assert.Equal(expected.Price, result.Price);
Assert.Equal(expected.TrainerId, result.TrainerId);
Assert.Equal(expected.Trainer.Name, result.TrainerName);
Assert.Equal(expected.StartDate.DaysTo(expected.EndDate), result.Duration);
Assert.Equal(!expected.StartDate.HasEnded(), result.CanEnroll);
result.RemainingTimeTillStart
.Should()
.BeCloseTo(expected.StartDate.RemainingTimeTillStart(), Precision);
}
private static void AssertSingleCourse(Course expectedItem, CourseServiceModel resultItem)
{
var dateTimeUtcNow = DateTime.UtcNow;
Assert.Equal(expectedItem.Id, resultItem.Id);
Assert.Equal(expectedItem.Name, resultItem.Name);
Assert.Equal(expectedItem.StartDate, resultItem.StartDate);
Assert.Equal(expectedItem.EndDate, resultItem.EndDate);
Assert.Equal(expectedItem.Price, resultItem.Price);
Assert.Equal(expectedItem.TrainerId, resultItem.TrainerId);
Assert.Equal(expectedItem.Trainer.Name, resultItem.TrainerName);
Assert.Equal(!expectedItem.StartDate.HasEnded(), resultItem.CanEnroll);
Assert.Equal(expectedItem.StartDate.DaysTo(expectedItem.EndDate), resultItem.Duration);
Assert.Equal(dateTimeUtcNow < expectedItem.StartDate, resultItem.IsUpcoming);
Assert.Equal(
expectedItem.StartDate <= dateTimeUtcNow && dateTimeUtcNow <= expectedItem.EndDate,
resultItem.IsActive);
resultItem.RemainingTimeTillStart
.Should()
.BeCloseTo(expectedItem.StartDate.RemainingTimeTillStart(), Precision);
}
public static Mock <ITrainerService> CourseByIdAsync(this Mock <ITrainerService> mock, CourseServiceModel course)
{
mock.Setup(s => s.CourseByIdAsync(It.IsAny <string>(), It.IsAny <int>()))
.ReturnsAsync(course)
.Verifiable();
return(mock);
}
public IHttpActionResult CourseById(Guid id)
{
var course = this.GetCourseById(id);
return(Ok(CourseServiceModel.ConvertFromCourse(course)));
}
public IHttpActionResult AllCourses()
{
var courses = this.data.Courses.All().ToList().Select(c => CourseServiceModel.ConvertFromCourse(c));
return(Ok(courses));
}
