/// <summary>
/// Updates a Note entity and persists any changes made to the DB.
/// </summary>
/// <param name="entity">The <see cref="Note"/> entity to update.</param>
/// <param name="model">The <see cref="NoteInputModel"/> model containing the updated data.</param>
/// <exception cref="ArgumentNullException"></exception>
public async Task <Note> Update(Note entity, NoteInputModel model)
{
if (entity == null)
{
throw new ArgumentNullException(nameof(entity));
}
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
try
{
var logItem = new NoteLogItem
{
TimeOriginallyCreated = entity.TimeLastUpdated,
TimeArchived = DateTime.Now,
Title = entity.Title,
Content = entity.Content
};
var newEntity = _mapper.Map <Note>(model);
newEntity.TimeLastUpdated = DateTime.Now;
newEntity.NoteLog.Add(logItem);
return(await _noteRepository.Update(entity.Id, newEntity));
}
catch (Exception e)
{
Log.Error("An error occurred updating an entity: {0}", e.Message);
throw;
}
}
public async Task When_Creating_A_Note_That_Is_Not_Associated_To_A_Task_Then_An_Error_Is_Returned()
{
var noteInputModel = new NoteInputModel(Guid.Empty, "Test");
var postNoteResponse = await _httpClient.PostAsJsonAsync(_noteEndpoint, noteInputModel);
postNoteResponse.IsSuccessStatusCode.Should().BeFalse();
}
public async Task TestPutValidEntityNull()
{
// Arrange
var testModel = new NoteInputModel {
PatientId = 1
};
var mockNoteService = new Mock <INoteService>();
mockNoteService
.Setup(x => x.GetByIdAsync(It.IsAny <string>()))
.ReturnsAsync(null as Note);
var mockExternalService = new Mock <IExternalAPIService>();
mockExternalService
.Setup(x => x.PatientExists(1))
.ReturnsAsync(true);
var controller = new HistoryController(mockNoteService.Object, mockExternalService.Object);
// Act
var result =
await controller.Put("abc", testModel);
// Assert
var actionResult =
Assert.IsAssignableFrom <NotFoundObjectResult>(result);
}
public async Task Given_A_Task_Then_An_Associacated_Note_Can_Be_Created_Through_The_Api()
{
var taskInputModel = _fixture.Create <AddTaskInputModel>();
var taskId = await PostTaskAsync(taskInputModel);
var noteInputModel = new NoteInputModel(taskId, _fixture.Create <string>());
var postNoteResponse = await _httpClient.PostAsJsonAsync(_noteEndpoint, noteInputModel);
postNoteResponse.IsSuccessStatusCode.Should().BeTrue();
}
private async Task <Guid> PostNoteAsync(NoteInputModel inputModel)
{
var postNoteResponse = await _httpClient.PostAsJsonAsync(_noteEndpoint, inputModel);
var postNoteResponseContent = await postNoteResponse.Content.ReadAsStringAsync();
var noteId = JsonConvert.DeserializeObject <Guid>(postNoteResponseContent);
return(noteId);
}
public IActionResult Note(NoteInputModel model)
{
var order = this.orders.Get(model.OrderId);
order.Note = string.IsNullOrWhiteSpace(model.Note)
? null
: model.Note;
this.orders.Save();
return(RedirectToAction(nameof(OrderController.Index)));
}
public IActionResult Create(NoteInputModel input)
{
if (!ModelState.IsValid)
{
return(View(input));
}
var note = _mapper.Map <Note>(input);
note.Updated = note.Created = DateTime.Now;
_notesService.AddNote(note);
_notesService.SaveChanges();
return(RedirectToAction("Edit", new { id = note.Id }));
}
public async Task Given_A_Note_When_It_Is_Deleted_Then_The_Note_Cannot_Be_Fetched()
{
var taskInputModel = _fixture.Create <AddTaskInputModel>();
var taskId = await PostTaskAsync(taskInputModel);
var noteInputModel = new NoteInputModel(taskId, _fixture.Create <string>());
var noteId = await PostNoteAsync(noteInputModel);
string specificNoteEndpoint = string.Format("{0}/{1}", _noteEndpoint, noteId);
await _httpClient.DeleteAsync(specificNoteEndpoint);
var noteResponse = await _httpClient.GetAsync(specificNoteEndpoint);
noteResponse.StatusCode.Should().Be(HttpStatusCode.NotFound);
}
public async Task Given_A_Task_When_Adding_A_Note_Then_The_Task_Has_A_Note()
{
var taskInputModel = _fixture.Create <AddTaskInputModel>();
var taskId = await PostTaskAsync(taskInputModel);
var noteInputModel = new NoteInputModel(taskId, _fixture.Create <string>());
await _httpClient.PostAsJsonAsync(_noteEndpoint, noteInputModel);
string taskEndpoint = string.Format("{0}/{1}", _taskEndpoint, taskId);
var getTaskResponse = await _httpClient.GetAsync(taskEndpoint);
string getTaskResponseContent = await getTaskResponse.Content.ReadAsStringAsync();
var taskViewModel = JsonConvert.DeserializeObject <TaskViewModel>(getTaskResponseContent);
taskViewModel.HasNote.Should().BeTrue();
}
public async Task Given_A_Task_With_A_Note_Then_The_Note_Can_Be_Fetched_Through_The_Api()
{
var taskInputModel = _fixture.Create <AddTaskInputModel>();
var taskId = await PostTaskAsync(taskInputModel);
var noteInputModel = new NoteInputModel(taskId, _fixture.Create <string>());
var noteId = await PostNoteAsync(noteInputModel);
var getNoteEndpoint = string.Format("http://localhost:9000/task/{0}/note", noteInputModel.TaskId);
var getNoteResponse = await _httpClient.GetAsync(getNoteEndpoint);
var getNoteResponseContent = await getNoteResponse.Content.ReadAsStringAsync();
var noteViewModel = JsonConvert.DeserializeObject <NoteViewModel>(getNoteResponseContent);
noteViewModel.Id.Should().Be(noteId);
}
public async Task Given_A_Note_Then_It_Can_Be_Updated()
{
var taskInputModel = _fixture.Create <AddTaskInputModel>();
var taskId = await PostTaskAsync(taskInputModel);
var noteInputModel = new NoteInputModel(taskId, _fixture.Create <string>());
var noteId = await PostNoteAsync(noteInputModel);
var updateNoteInputModel = new UpdateNoteInputModel(_fixture.Create <string>());
string specificNoteEndpoint = string.Format("{0}/{1}", _noteEndpoint, noteId);
var result = await _httpClient.PostAsJsonAsync(specificNoteEndpoint, updateNoteInputModel);
var noteResponse = await _httpClient.GetAsync(specificNoteEndpoint);
string noteResponseContent = await noteResponse.Content.ReadAsStringAsync();
var noteViewModel = JsonConvert.DeserializeObject <NoteViewModel>(noteResponseContent);
noteViewModel.Text.Should().Be(updateNoteInputModel.Text);
}
public async Task TestUpdateModelValid()
{
// Arrange
var testEntity = new Note
{
Id = Guid.NewGuid().ToString()
};
var testModel = new NoteInputModel
{
Title = "Test"
};
var mockRepository = new Mock <INoteRepository>();
mockRepository
.Setup(x => x.Update(testEntity.Id, It.IsAny <Note>()))
.ReturnsAsync((string id, Note note) => new Note
{
Id = id,
Title = note.Title
})
.Verifiable();
var service = new NoteService(_mapper, mockRepository.Object);
// Act
var result = await service.Update(testEntity, testModel);
// Assert
Assert.NotNull(result);
Assert.Equal("Test", result.Title);
mockRepository
.Verify(
x => x.Update(It.IsAny <string>(), It.IsAny <Note>()),
Times.Once());
}
/// <summary>
/// Component initialisation logic.
/// </summary>
/// <returns></returns>
protected override async Task OnInitializedAsync()
{
SetComponentMode();
if (Mode == ComponentMode.Create)
{
InputModel = new NoteInputModel {
PatientId = PatientId
};
OperationStatus = APIOperationStatus.GET_Success;
StateHasChanged();
}
else
{
OperationStatus = APIOperationStatus.GET_Pending;
StateHasChanged();
await GetNote();
OperationStatus = APIOperationStatus.GET_Success;
StateHasChanged();
}
}
public async Task TestPutValid()
{
// Arrange
var testModel = new NoteInputModel {
PatientId = 1
};
var testNoteId = Guid.NewGuid().ToString();
var mockNoteService = new Mock <INoteService>();
mockNoteService
.Setup(x => x.GetByIdAsync(It.IsAny <string>()))
.ReturnsAsync(new Note {
Id = testNoteId
});
mockNoteService
.Setup(x => x.Update(It.IsAny <Note>(), It.IsAny <NoteInputModel>()))
.Verifiable();
var mockExternalService = new Mock <IExternalAPIService>();
mockExternalService
.Setup(x => x.PatientExists(1))
.ReturnsAsync(true);
var controller = new HistoryController(mockNoteService.Object, mockExternalService.Object);
// Act
var result =
await controller.Put("abc", testModel);
// Assert
var actionResult =
Assert.IsAssignableFrom <NoContentResult>(result);
}
public async Task <ActionResult> Put(string id, NoteInputModel model)
{
if (string.IsNullOrWhiteSpace(id) ||
model == null)
{
return(BadRequest());
}
if (!await _externalApiService.PatientExists(model.PatientId))
{
return(NotFound("Patient not found"));
}
var entity = await _noteService.GetByIdAsync(id);
if (entity == null)
{
return(NotFound(new { message = "Note not found" }));
}
await _noteService.Update(entity, model);
return(NoContent());
}
public async Task Given_A_Task_With_A_Note_When_It_Is_Deleted_Then_The_Task_Has_No_Note()
{
var taskInputModel = _fixture.Create <AddTaskInputModel>();
var taskId = await PostTaskAsync(taskInputModel);
var noteInputModel = new NoteInputModel(taskId, _fixture.Create <string>());
var postNoteResponse = await _httpClient.PostAsJsonAsync(_noteEndpoint, noteInputModel);
string postNoteResponseContent = await postNoteResponse.Content.ReadAsStringAsync();
var noteId = JsonConvert.DeserializeObject <Guid>(postNoteResponseContent);
string specificNoteEndpoint = string.Format("{0}/{1}", _noteEndpoint, noteId);
await _httpClient.DeleteAsync(specificNoteEndpoint);
string specificTaskEndpoint = string.Format("{0}/{1}", _taskEndpoint, taskId);
var getTaskResponse = await _httpClient.GetAsync(specificTaskEndpoint);
string getTaskResponseContent = await getTaskResponse.Content.ReadAsStringAsync();
var taskViewModel = JsonConvert.DeserializeObject <TaskViewModel>(getTaskResponseContent);
taskViewModel.HasNote.Should().BeFalse();
}
