public async Task Should_AddNewStudent()
{
// arrange
ActionResult <StudentResponse> result;
var studentRequest = new CreateStudentRequest {
Name = fixture.NewStudent.Name
};
Student studentResult;
// act
using (var dbContext = new BlogPostContext(fixture.Options))
{
var controller = new StudentsController(dbContext, fixture.Mapper, studentServiceMock.Object, studentRepositoryMock.Object);
result = await controller.PostStudent(studentRequest);
studentResult = dbContext.Students.FirstOrDefault(x => x.Name == fixture.NewStudent.Name);
}
var apiResult = result.Result.As <CreatedAtActionResult>();
var students = apiResult.Value.As <StudentResponse>();
// assert
apiResult.StatusCode.Should().Be(StatusCodes.Status201Created);
students.Should().BeEquivalentTo(studentResult);
}
public async Task Post_AddStudent_AddsStudentAndReturnsAddedStudent()
{
// arrange
if (!_isIntegrationTestsEnabled)
{
return;
}
var httpClient = new HttpClient();
var createStudentRequest = new CreateStudentRequest
{
FirstName = "John",
LastName = "Smith",
Email = "*****@*****.**",
StudentTypeId = 1
};
// act
var response = await httpClient.PostAsJsonAsync($"{_sampleWebApiBaseUrl}students", createStudentRequest);
// assert
Assert.True(response.IsSuccessStatusCode);
Assert.True(response.StatusCode == HttpStatusCode.OK);
var student = await response.Content.ReadAsJsonAsync <StudentDto>();
Assert.NotNull(student);
Assert.Equal("John", student.FirstName);
await Task.Delay(1000);
await TestGetAllStudents(httpClient);
}
public StudentResponse Create(CreateStudentRequest createStudentRequest)
{
var student = createStudentRequest.To <Student>();
var createdStudent = _studentService.Create(student);
return(ReadById(createdStudent.Id));
}
public Task <Student> CreateStudent(CreateStudentRequest request)
{
return(_studentsService.CreateStudent(
new Student
{
FirstName = request.FirstName, LastName = request.LastName
}));
}
public async Task <IActionResult> CreateStudent(StudentDto student)
{
var request = new CreateStudentRequest {
Student = student
};
await _studentService.Create(request);
return(RedirectToAction(nameof(GetStudents)));
}
public async Task CreateStudentAsync(CreateStudentRequest student)
{
if (student == null)
{
throw new InvalidArgumentException("Create student request model cannot be empty.");
}
var dbStudent = _mapper.Map <DbStudent>(student);
await _unitOfWork.StudentRepository.CreateAsync(dbStudent);
}
public async Task <IActionResult> Post([FromBody] CreateStudentRequest model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var createdModel = await _service.CreateAsync(model);
return(CreatedAtAction(nameof(Get), new { createdModel.Id }, createdModel));
}
internal Student(CreateStudentRequest request, string studentType)
{
StudentId = Guid.NewGuid();
FirstName = request.FirstName;
LastName = request.LastName;
StudentTypeId = request.StudentTypeId;
Email = request.Email;
RaiseEvent(new StudentCreatedEvent(StudentId, FirstName, LastName,
Email, StudentTypeId, studentType));
}
public async Task <ActionResult <StudentResponse> > PostStudent([FromBody] CreateStudentRequest request)
{
var student = mapper.Map <Student>(request);
context.Students.Add(student);
await context.SaveChangesAsync();
var studentResponse = mapper.Map <StudentResponse>(student);
return(CreatedAtAction("GetStudent", new { id = studentResponse.Id }, studentResponse));
}
public async Task <IActionResult> CreateNewStudent([FromBody] CreateStudentRequest request)
{
var studentEntity = new Student
{
FirstName = request.FirstName,
LastName = request.LastName
};
await _studentMapperSession.AddAsync(studentEntity);
return(Ok());
}
public async Task <ActionResult> Post(CreateStudentRequest studentRequest)
{
return
((await _operationInvoker.InvokeAsync(
new CreateStudentCommand(
new Student
{
PublicKey = Guid.NewGuid(),
DateOfBirth = studentRequest.DateOfBirth,
Firstname = studentRequest.Firstname,
Surname = studentRequest.Surname
}))).ToActionResult());
}
public async Task <ActionResult> Create(CreateStudentRequest request)
{
var student = new StudentEntity
{
FirstName = request.FirstName,
LastName = request.LastName,
DateOfBirth = request.DateOfBirth.Value
};
_schoolDbContext.Students.Add(student);
await _schoolDbContext.SaveChangesAsync();
return(null);
}
internal Student(CreateStudentRequest request, string studentType)
{
Id = Guid.NewGuid();
FirstName = request.FirstName;
LastName = request.LastName;
StudentTypeId = request.StudentTypeId;
RaiseEvent(new StudentCreatedEvent
{
StudentId = Id,
FirstName = FirstName,
LastName = LastName,
StudentType = studentType,
StudentTypeId = StudentTypeId
});
}
/// <inheritdoc/>
public async Task <StudentResponse> CreateAsync(CreateStudentRequest model)
{
var now = DateTime.Now;
var createdModel = new Student
{
Name = model.Name,
CreatedBy = "",
CreatedDate = now,
ModifiedBy = "",
ModifiedDate = now
};
createdModel = await _repository.CreateAsync(createdModel);
return(PrepareStudentResponse(createdModel));
}
public async Task <IActionResult> CreateStudent([FromRoute] Guid schoolId, [FromBody] CreateStudentRequest request)
{
var school = await _studentService.GetSchool(schoolId);
if (school == null)
{
return(NotFound());
}
var student = new Student
{
Id = Guid.NewGuid(),
Name = request.Name,
SchoolId = schoolId,
CreatedTime = _dateTimeService.UtcNow
};
await _studentService.CreateStudent(student);
return(Ok(StudentDto.Map(student)));
}
public async Task <BasicResponse> Create(CreateStudentRequest request)
{
var response = new BasicResponse {
Status = Status.NotAuthorized
};
try
{
var student = request.Student.MapToModel(_mapper);
await _studentRepository.Create(student);
response.Status = Status.Ok;
}
catch (Exception ex)
{
response.Status = Status.InvalidData;
response.Message = ex.Message;
}
return(response);
}
public async Task SetStudents([FromBody] CreateStudentRequest model)
{
await _studentServices.SetStudents(model.Students);
}
public async Task <Guid> Post(CreateStudentRequest request)
{
return(await _mediator.ProcessAsync(request));
}
public async Task <StudentDto> Post([FromBody] CreateStudentRequest request,
CancellationToken cancellationToken)
{
return(await _requestor.ProcessAsync(request, cancellationToken));
}
public async Task <IActionResult> CreateStudent(CreateStudentRequest student)
{
await _studentsService.CreateStudentAsync(student);
return(NoContent());
}
public async Task <IActionResult> CreateStudent(CreateStudentRequest request)
{
var result = await _studentService.CreateAsync(request);
return(Ok(result.Value));
}
public ActionResult AddStudent(CreateStudentRequest createRequest)
{
var newStudent = _studentRepository.AddStudent(createRequest.FirstName, createRequest.LastName);
return(Created($"/api/student/{newStudent.Id}", newStudent));
}
