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