public async Task <BaseResponse <Patient> > Handle(CreatePatientCommand request, CancellationToken cancellationToken) { var response = new BaseResponse <Patient> () { ReponseName = nameof(CreatePatientCommand), Content = new List <Patient> () { } }; var entity = _mapper.Map <Patient> (request); var newentity = await _patientRepository.AddAsync(entity); if (newentity == null) { response.Status = ResponseType.Error; response.Message = $"{nameof(Patient)} could not be created."; response.Content = null; } else { response.Status = ResponseType.Success; response.Message = $"{nameof(Patient)} created successfully."; response.Content.Add(newentity); } return(response); }
public void ShouldValidateWhenCommandIsValid() { var command = new CreatePatientCommand(); command.Name = "Gian Mella"; command.Phone = "(51) 98184-1977"; command.DateOfBirth = new DateTime(1990, 26, 06); Assert.AreEqual(true, command.IsValid()); }
public async Task <IActionResult> Create([FromBody] CreatePatientCommand createPatientCommand) { var response = await _mediator.Send(createPatientCommand); if (response.Errors.Any()) { return(BadRequest(new { Errors = response.Errors })); } return(Created("", null)); }
public async Task <IActionResult> Post([FromHeader] Guid userId, [FromBody] CreatePatientCommand command) { var patientId = await patientLogic.SavePatient(command); if (patientId == Guid.Empty) { return(BadRequest()); } return(CreatedAtAction(nameof(GetPatient), new { id = patientId }, patientId)); }
public void ShouldRegisterCustomerWhenCommandIsValid() { var command = new CreatePatientCommand(); command.Name = "Gian Mella"; command.Phone = "(51) 98184-1977"; command.DateOfBirth = new DateTime(1990, 26, 06); //Assert.AreNotEqual(null, result); //Assert.AreEqual(true, handler.Valid); }
public async Task <ActionResult <BaseResponse <Patient> > > CreatePatient(CreatePatientCommand command) { try { var result = await _mediator.Send(command); return(Ok(result)); } catch (ValidationException ex) { var err = new BaseResponse <Patient> (); err.Status = ResponseType.Error; err.Message = ex.Message; err.Content = null; return(Ok(err)); } }
public void CreatePatientCommand_MapperThrowsException_PatientIsNotCreated() { var mapperMock = Substitute.For <IMapper>(); var loggerMock = Substitute.For <ILogger <CreatePatientCommand> >(); CreatePatientCommand testCommand = new CreatePatientCommand { Surname = "Steve" }; mapperMock.Map <Patient>( Arg.Any <CreatePatientCommand>()).Returns(x => { throw new Exception(); }); var sut = new CreatePatientCommand.Handler(_myPregnancyDbContext, mapperMock, loggerMock); Assert.ThrowsAsync <Exception>(async() => await sut.Handle(testCommand, CancellationToken.None)); Assert.That(_myPregnancyDbContext.Patient.ToList(), Is.Empty); }
public void CreatePatientCommandValidator_NullProperties_FailsValidation() { CreatePatientCommand patientCommand = new CreatePatientCommand(); _validator.ShouldHaveValidationErrorFor(x => x.PreferredName, patientCommand); _validator.ShouldHaveValidationErrorFor(x => x.Forenames, patientCommand); _validator.ShouldHaveValidationErrorFor(x => x.Surname, patientCommand); _validator.ShouldHaveValidationErrorFor(x => x.Language, patientCommand); _validator.ShouldHaveValidationErrorFor(x => x.DateOfBirth, patientCommand); _validator.ShouldHaveValidationErrorFor(x => x.MobileTelephone, patientCommand); _validator.ShouldHaveValidationErrorFor(x => x.HomeTelephone, patientCommand); _validator.ShouldHaveValidationErrorFor(x => x.HealthCareNumber, patientCommand); _validator.ShouldHaveValidationErrorFor(x => x.KnownAllergies, patientCommand); _validator.ShouldHaveValidationErrorFor(x => x.AddressLine1, patientCommand); _validator.ShouldHaveValidationErrorFor(x => x.AddressLine2, patientCommand); _validator.ShouldHaveValidationErrorFor(x => x.City, patientCommand); _validator.ShouldHaveValidationErrorFor(x => x.Postcode, patientCommand); }
public async Task CreatePatientCommand_ValidCreateCommand_SuccessfullyCreatesPatient() { var mapperMock = Substitute.For <IMapper>(); var loggerMock = Substitute.For <ILogger <CreatePatientCommand> >(); CreatePatientCommand testCommand = new CreatePatientCommand { Surname = "Steve" }; mapperMock.Map <Patient>(Arg.Is <CreatePatientCommand>(x => x.Surname == testCommand.Surname)) .Returns(new Patient { Surname = "test1" }); var sut = new CreatePatientCommand.Handler(_myPregnancyDbContext, mapperMock, loggerMock); var result = await sut.Handle(testCommand, CancellationToken.None); mapperMock.Received(1).Map <Patient>(Arg.Any <CreatePatientCommand>()); Assert.That(result, Is.EqualTo(1)); }
public async Task <Guid> SavePatient(CreatePatientCommand command) { var patient = mapper.Map <Entities.Patient>(command); patient.Id = Guid.NewGuid(); patient.IsActive = true; patient.Created = DateTime.UtcNow; patient.CreatedBy = command.CreatedBy; patient.Updated = DateTime.UtcNow; patient.UpdatedBy = command.CreatedBy; await context.Patient.AddAsync(patient); var rowChanged = await context.SaveChangesAsync(); if (rowChanged == 0) { return(Guid.Empty); } return(patient.Id); }
public async Task PatientsControllerCreate_ValidCreatePatientCommand_CommandSentSuccessfully() { int successfulCreationId = 1; var mediatorMock = Substitute.For <IMediator>(); var loggerMock = Substitute.For <ILogger <PatientsController> >(); mediatorMock.Send(Arg.Any <CreatePatientCommand>()).Returns(successfulCreationId); CreatePatientCommand testCommand = new CreatePatientCommand { Surname = "Steve" }; var sut = new PatientsController(mediatorMock, loggerMock); var result = await sut.Create(testCommand); var okResult = result as OkObjectResult; Assert.IsNotNull(okResult); Assert.That(okResult.StatusCode, Is.EqualTo(200)); Assert.That(okResult.Value, Is.EqualTo(successfulCreationId)); await mediatorMock.Received(1).Send(Arg.Is <CreatePatientCommand>(x => x.Surname == testCommand.Surname)); loggerMock.Received(1); }
public async Task <IActionResult> Create([FromBody] CreatePatientCommand command) { _logger.LogInformation($"Entering {nameof(Create)}"); return(Ok(await _mediator.Send(command))); }
public async Task <ActionResult <int> > Create([FromBody] CreatePatientCommand command) { var newId = await Mediator.Send(command); return(CreatedAtAction(nameof(Get), new { id = newId }, newId)); }
public async Task <IActionResult> InsertAsync(CreatePatientCommand command) { await _mediator.Send(command); return(Success()); }
public ICommandResult Post([FromBody] CreatePatientCommand command) { var result = (CommandResult)_handler.Handle(command); return(result); }
public CreatePatientViewModel(IBus bus) { _bus = bus; _command = new CreatePatientCommand(Guid.NewGuid()); }
public async Task <ActionResult <int> > Create(CreatePatientCommand command) { return(await Mediator.Send(command)); }
public async Task <ActionResult> CreatePatient([FromBody] CreatePatientCommand command) { var patient = await Mediator.Send(command); return(CreatedAtAction("GetPatient", new { id = patient.Id }, patient)); }