public async Task <Response <SignUpResult> > SignUpToCourse(SignUpToCourseDto signUpToCourse)
{
var course = _courseRepository.GetById(signUpToCourse.IdCourse);
if (course == null)
{
return(new Response <SignUpResult>(false, "Course Id not found!", null));
}
if (await GetIsFullCapacity(course.Capacity, course.Id))
{
return(new Response <SignUpResult>(false, "Course is full!", null));
}
var singUp = new SignUpToCourse(
Guid.NewGuid(),
signUpToCourse.IdCourse
);
singUp.AlterStudent(
new Student(Guid.NewGuid(),
signUpToCourse.Student.Name,
signUpToCourse.Student.Email,
signUpToCourse.Student.DateOfBirth
));
_signUpToCourseRepository.Add(singUp);
Commit();
return(new Response <SignUpResult>(false, String.Empty, new SignUpResult
{
Message = "Congratulations, singUp is complete"
}));
}
public void Signup(SignUpToCourseDto courseSignUp)
{
//Criar o respositorio Student e gravar o aluno quando não existir
//Obter a agenda do curso para pegar a ultima data
var student = new Student(); // <- Esse seria o estudante criado/existente
var dataCurso = new DateTime();
eventBus.Publish(new SignUpEvent(student.Id, courseSignUp.CourseId, dataCurso));
}
public async Task <ActionResult <ResultDto> > SignUpStudentAsync(
[FromBody] SignUpToCourseDto signupCourseParameter,
[FromServices] CourseBusiness courseBusiness)
{
if (!this.ModelState.IsValid)
{
return(this.BadRequest(this.ModelState));
}
return(await courseBusiness.SignUpStudentAsync(signupCourseParameter));
}
private static async Task SendSingUpsCourses(SignUpToCourseDto singUp)
{
try
{
var json = JsonConvert.SerializeObject(singUp);
var data = new StringContent(json, Encoding.UTF8, "application/json");
var url = "https://localhost:5001/Courses/sign-up";
using var client = new HttpClient();
var response = await client.PostAsync(url, data);
var result = response.Content.ReadAsStringAsync().Result;
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
private async Task <ResultDto> EnsureIsValidAsync(SignUpToCourseDto signupCourseParameter)
{
var result = new ResultDto();
if (signupCourseParameter.Student == null)
{
result.Messages.Add("Student not informed.");
}
else
{
var student = await this.dbContext.Students
.Where(s => s.Email == signupCourseParameter.Student.Email)
.SingleOrDefaultAsync();
if (student == null)
{
result.Messages.Add("There's no student with this email.");
}
else
{
signupCourseParameter.Student.Id = student.Id;
var course = await this.dbContext.Courses
.Where(c => c.Id == signupCourseParameter.CourseId)
.SingleOrDefaultAsync();
if (course == null)
{
result.Messages.Add("The course doesn't exists.");
}
else
{
result.Success = true;
}
}
}
return(result);
}
public async Task <IActionResult> Post([FromBody] SignUpToCourseDto model)
{
if (ModelState.IsValid)
{
var appResponse = await _signUpApplication.SignUpStudentToCourseAsync(model.CourseId, model.Student);
if (appResponse.Succeeded)
{
return(Ok(appResponse.Message));
}
else
{
ModelState.AddModelError("Error", appResponse.Message);
ModelState.AddModelError("Details", string.Join(", ", appResponse.Errors));
return(BadRequest(ModelState));
}
}
else
{
return(BadRequest(ModelState));
}
}
private async Task <ResultDto> EnsureTheBusinessRulesAsync(SignUpToCourseDto signupCourseParameter)
{
var result = new ResultDto();
var courseInfo = await dbContext.Courses
.Where(c => c.Id == signupCourseParameter.CourseId)
.Select(c => new CourseDto()
{
Capacity = c.Capacity,
NumberOfStudents = c.NumberOfStudents
})
.SingleOrDefaultAsync();
if (courseInfo == null)
{
result.Messages.Add("Course not found.");
}
else if (courseInfo.Capacity == courseInfo.NumberOfStudents)
{
result.Messages.Add("Hey buddy, the course is full, go home!!");
}
else
{
if (await dbContext.StudentsCourses.AnyAsync(sc => sc.StudentId == signupCourseParameter.Student.Id &&
sc.CourseId == signupCourseParameter.CourseId))
{
result.Messages.Add("You can't signup for this course again");
}
else
{
result.Success = true;
}
}
return(result);
}
public async Task <ResultDto> SignUpStudentAsync(SignUpToCourseDto signupCourseParameter)
{
var result = new ResultDto();
var valid = await EnsureIsValidAsync(signupCourseParameter);
var businessValidation = await EnsureTheBusinessRulesAsync(signupCourseParameter);
if (valid.Success && businessValidation.Success)
{
var newStudentCourse = new StudentCourse()
{
CourseId = signupCourseParameter.CourseId,
StudentId = signupCourseParameter.Student.Id
};
this.dbContext.StudentsCourses.Add(newStudentCourse);
await this.dbContext.SaveChangesAsync();
//Update the course info.
var courseInfo = await this.dbContext.Courses
.Where(c => c.Id == signupCourseParameter.CourseId)
.FirstOrDefaultAsync();
courseInfo.NumberOfStudents += 1;
await this.dbContext.SaveChangesAsync();
result.Success = true;
}
else
{
//The worker tries to sign up the student then notifies the student whether signing up succeeded or not
result.Messages.AddRange(valid.Messages);
result.Messages.AddRange(businessValidation.Messages);
}
return(result);
}
public Task <IActionResult> Post([FromBody] SignUpToCourseDto signUpToCourseDto)
{
throw new NotImplementedException();
}
