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)); }