Ejemplo n.º 1
0
        public async Task <Either <ActionResult, MethodologyNoteViewModel> > UpdateNote(
            Guid methodologyVersionId,
            Guid methodologyNoteId,
            MethodologyNoteUpdateRequest request)
        {
            return(await _persistenceHelper
                   .CheckEntityExists <MethodologyNote>(q =>
                                                        q.Include(n => n.MethodologyVersion)
                                                        .Where(
                                                            n => n.Id == methodologyNoteId &&
                                                            n.MethodologyVersionId == methodologyVersionId))
                   .OnSuccessDo(methodologyNote =>
                                _userService.CheckCanUpdateMethodology(methodologyNote.MethodologyVersion))
                   .OnSuccess(async methodologyNote =>
            {
                var updatedNote = await _methodologyNoteRepository.UpdateNote(
                    methodologyNoteId: methodologyNoteId,
                    updatedByUserId: _userService.GetUserId(),
                    content: request.Content,
                    displayDate: request.DisplayDate ?? DateTime.Today.ToUniversalTime()
                    );

                return BuildMethodologyNoteViewModel(updatedNote);
            }));
        }
 public async Task <ActionResult <MethodologyNoteViewModel> > UpdateNote(
     Guid methodologyVersionId, Guid methodologyNoteId, MethodologyNoteUpdateRequest request)
 {
     return(await _methodologyNoteService
            .UpdateNote(methodologyVersionId, methodologyNoteId, request)
            .HandleFailuresOrOk());
 }
        public async Task UpdateNote_NoDisplayDateDefaultsToToday()
        {
            var methodologyVersion = new MethodologyVersion
            {
                Notes = new List <MethodologyNote>
                {
                    new()
                    {
                        Content     = "Original note",
                        DisplayDate = DateTime.Today.AddDays(-7).ToUniversalTime()
                    }
                }
            };

            var request = new MethodologyNoteUpdateRequest
            {
                Content     = "Updating note",
                DisplayDate = null
            };

            var today = DateTime.Today.ToUniversalTime();

            var contentDbContextId = Guid.NewGuid().ToString();

            await using (var contentDbContext = InMemoryApplicationDbContext(contentDbContextId))
            {
                await contentDbContext.MethodologyVersions.AddAsync(methodologyVersion);

                await contentDbContext.SaveChangesAsync();
            }

            await using (var contentDbContext = InMemoryApplicationDbContext(contentDbContextId))
            {
                var service = SetupMethodologyNoteService(contentDbContext);

                var result = (await service.UpdateNote(
                                  methodologyVersionId: methodologyVersion.Id,
                                  methodologyNoteId: methodologyVersion.Notes[0].Id,
                                  request: request)).AssertRight();

                Assert.Equal(methodologyVersion.Notes[0].Id, result.Id);
                Assert.Equal(request.Content, result.Content);
                Assert.Equal(today, result.DisplayDate);
            }

            await using (var contentDbContext = InMemoryApplicationDbContext(contentDbContextId))
            {
                var updatedNote =
                    await contentDbContext.MethodologyNotes.SingleAsync(n => n.Id == methodologyVersion.Notes[0].Id);

                Assert.Equal(request.Content, updatedNote.Content);
                Assert.Equal(today, updatedNote.DisplayDate);
            }
        }