VIH-10839 Replace polling for hearings with events

VideoWeb/VideoWeb.Common/Caching/ConferenceCache.cs

@@ -34,5 +34,11 @@ public async Task<Conference> GetOrAddConferenceAsync(Guid id, Func<Task<(Confer
             conference = await Task.FromResult(memoryCache.Get<Conference>(id));
             return conference;
         }
+
+        public Task RemoveConferenceAsync(Conference conference, CancellationToken cancellationToken = default)
+        {
+            memoryCache.Remove(conference.Id);
+            return Task.CompletedTask;
+        }
     }
 }

VideoWeb/VideoWeb.Common/Caching/DistributedConferenceCache.cs

@@ -46,6 +46,11 @@ public async Task<Conference> GetOrAddConferenceAsync(Guid id, Func<Task<(Confer
 
             return conference;
         }
+
+        public async Task RemoveConferenceAsync(Conference conference, CancellationToken cancellationToken = default)
+        {
+            await RemoveFromCache(conference.Id, cancellationToken);
+        }
 
         protected override string GetKey(Guid key)
         {

VideoWeb/VideoWeb.Common/Caching/IConferenceCache.cs

@@ -12,5 +12,6 @@ public interface IConferenceCache
         Task AddConferenceAsync(ConferenceDetailsResponse conferenceResponse, HearingDetailsResponseV2 hearingDetailsResponse, CancellationToken cancellationToken = default);
         Task UpdateConferenceAsync(Conference conference, CancellationToken cancellationToken = default);
         Task <Conference> GetOrAddConferenceAsync(Guid id, Func<Task<(ConferenceDetailsResponse, HearingDetailsResponseV2)>> addConferenceDetailsFactory, CancellationToken cancellationToken = default);
+        Task RemoveConferenceAsync(Conference conference, CancellationToken cancellationToken = default);
     }
 }

VideoWeb/VideoWeb.Common/ConferenceService.cs

@@ -18,6 +18,7 @@ public interface IConferenceService
     public Task<Conference> ForceGetConference(Guid conferenceId, CancellationToken cancellationToken = default);
     public Task UpdateConferenceAsync(Conference conference, CancellationToken cancellationToken = default);
     public Task<IEnumerable<Conference>> GetConferences(IEnumerable<Guid> conferenceIds, CancellationToken cancellationToken = default);
+    public Task RemoveConference(Conference conference, CancellationToken cancellationToken = default);
 }
 
 public class ConferenceService(
@@ -69,4 +70,9 @@ public async Task<IEnumerable<Conference>> GetConferences(IEnumerable<Guid> conf
         var ids = conferenceIds.ToArray();
         return await Task.WhenAll(ids.Select(id => GetConference(id, cancellationToken)));
     }
+
+    public async Task RemoveConference(Conference conference, CancellationToken cancellationToken = default)
+    {
+        await conferenceCache.RemoveConferenceAsync(conference, cancellationToken);
+    }
 }

VideoWeb/VideoWeb.EventHub/Enums/EventType.cs

@@ -24,8 +24,6 @@ public enum EventType
         EndpointTransfer,
         ParticipantsUpdated,
         NewConferenceAdded,
-        AllocationHearings,
-        HearingCancelled,
-        HearingDetailsUpdated
+        AllocationHearings
     }
 }

VideoWeb/VideoWeb.EventHub/Handlers/NewConferenceAddedEventHandler.cs

@@ -1,6 +1,7 @@
 using Microsoft.Extensions.Logging;
 using System;
 using System.Threading.Tasks;
+using VideoWeb.Common.Models;
 using VideoWeb.EventHub.Enums;
 
 namespace VideoWeb.EventHub.Handlers
@@ -22,8 +23,10 @@ private async Task PublishNewConferenceAddedMessage(Guid conferenceId)
         {
             foreach (var participant in SourceConference.Participants)
             {
-                await HubContext.Clients.Group(participant.Username.ToLowerInvariant())
-                    .NewConferenceAddedMessage(SourceConference.Id);
+                // Staff members already receive a message via the staff members group below, so don't message them here as well
+                if (participant.Role != Role.StaffMember)
+                    await HubContext.Clients.Group(participant.Username.ToLowerInvariant())
+                        .NewConferenceAddedMessage(SourceConference.Id);
             }
 
             await HubContext.Clients.Group(Hub.EventHub.VhOfficersGroupName)

VideoWeb/VideoWeb.EventHub/Handlers/ParticipantsUpdatedEventHandler.cs

@@ -1,6 +1,7 @@
 using System.Collections.Generic;
 using Microsoft.Extensions.Logging;
 using System.Threading.Tasks;
+using VideoWeb.Common.Models;
 using VideoWeb.Contract.Responses;
 using EventType = VideoWeb.EventHub.Enums.EventType;
 
@@ -25,10 +26,14 @@ private async Task PublishParticipantsUpdatedMessage(List<ParticipantResponse> u
     {
         foreach (var participant in participantsToNotify)
         {
-            await HubContext.Clients.Group(participant.UserName.ToLowerInvariant())
-                .ParticipantsUpdatedMessage(SourceConference.Id, updatedParticipants);
-            Logger.LogTrace("{UserName} | Role: {Role}", participant.UserName,
-                participant.Role);
+            // Staff members already receive a message via the staff members group below, so don't message them here as well
+            if (participant.Role != Role.StaffMember)
+            {
+                await HubContext.Clients.Group(participant.UserName.ToLowerInvariant())
+                    .ParticipantsUpdatedMessage(SourceConference.Id, updatedParticipants);
+                Logger.LogTrace("{UserName} | Role: {Role}", participant.UserName,
+                    participant.Role);
+            }
         }
 
         await HubContext.Clients.Group(Hub.EventHub.VhOfficersGroupName)

VideoWeb/VideoWeb.EventHub/Hub/IEventHubClient.cs

@@ -49,8 +49,8 @@ Task ReceiveMessage(Guid conferenceId, string from, string fromDisplayName, stri
         Task NewConferenceAddedMessage(Guid conferenceId);
         Task AllocationHearings(string csoUserName, List<HearingDetailRequest> hearings);
         Task EndpointsUpdated(Guid conferenceId, UpdateEndpointsDto endpoints);
-        Task HearingCancelledMessage(Guid hearingId);
-        Task HearingDetailsUpdatedMessage(Guid hearingId);
+        Task HearingCancelledMessage(Guid conferenceId);
+        Task HearingDetailsUpdatedMessage(Guid conferenceId);
 
         /// <summary>
         /// Request a participant's local mute be update. Not to be confused with remote mute (and lock).

VideoWeb/VideoWeb.UnitTests/Builders/EventComponentHelper.cs

@@ -88,6 +88,12 @@ public void RegisterUsersForHubContext(IEnumerable<Participant> participants)
         EventHubContextMock.Setup(x => x.Clients.Group(EventHub.Hub.EventHub.StaffMembersGroupName))
             .Returns(EventHubClientMock.Object);
     }
+
+    public void RegisterParticipantForHubContext(Participant participant)
+    {
+        EventHubContextMock.Setup(x => x.Clients.Group(participant.Username.ToLowerInvariant()))
+            .Returns(EventHubClientMock.Object);
+    }
 
     public Conference BuildConferenceForTest()
     {

VideoWeb/VideoWeb.UnitTests/Cache/ConferenceCacheTest.cs

@@ -5,6 +5,7 @@
 using NUnit.Framework;
 using VideoWeb.Common.Caching;
 using VideoWeb.Common.Models;
+using VideoWeb.UnitTests.Builders;
 
 namespace VideoWeb.UnitTests.Cache
 {
@@ -73,5 +74,20 @@ public async Task GetOrAddConferenceAsync_should_return_conference_when_cache_do
             result.Should().NotBeNull();
             result.Id.Should().Be(conferenceDetails.Id);
         }
+
+        [Test]
+        public async Task RemoveConferenceAsync_should_remove_conference_from_cache()
+        {
+            // Arrange
+            var conference = new ConferenceCacheModelBuilder().Build();
+            _memoryCache.Set(conference.Id, conference);
+
+            // Act
+            await _conferenceCache.RemoveConferenceAsync(conference);
+
+            // Assert
+            var conferenceInCache = _memoryCache.Get(conference.Id);
+            conferenceInCache.Should().BeNull();
+        }
     }
 }

VideoWeb/VideoWeb.UnitTests/Cache/DistributedConferenceCacheTests.cs

@@ -63,6 +63,28 @@ public async Task GetOrAddConferenceAsync_should_return_conference_when_cache_do
             result.Should().BeEquivalentTo(conference);
         }
 
+        [Test]
+        public async Task RemoveConferenceAsync_should_remove_conference_from_cache()
+        {
+            // Arrange
+            var conferenceResponse = CreateConferenceResponse();
+            var hearingDetails = CreateHearingResponse(conferenceResponse);
+            var conference = ConferenceCacheMapper.MapConferenceToCacheModel(conferenceResponse, hearingDetails);
+            var serialisedConference = JsonConvert.SerializeObject(conference, SerializerSettings);
+            var rawData = Encoding.UTF8.GetBytes(serialisedConference);
+            _distributedCacheMock
+                .Setup(x => x.GetAsync(conference.Id.ToString(), CancellationToken.None))
+                .ReturnsAsync(rawData);
+
+            var cache = new DistributedConferenceCache(_distributedCacheMock.Object, _loggerMock.Object);
+
+            // Act
+            await cache.RemoveConferenceAsync(conference);
+
+            // Assert
+            _distributedCacheMock.Verify(x => x.RemoveAsync(conference.Id.ToString(), default), Times.Once);
+        }
+
         private static JsonSerializerSettings SerializerSettings => new () { TypeNameHandling = TypeNameHandling.Objects, Formatting = Formatting.None };
     }
 }

VideoWeb/VideoWeb.UnitTests/Common/ConferenceServiceTests/RemoveConferenceTests.cs

@@ -0,0 +1,41 @@
+using System.Threading.Tasks;
+using BookingsApi.Client;
+using Moq;
+using NUnit.Framework;
+using VideoApi.Client;
+using VideoWeb.Common;
+using VideoWeb.Common.Caching;
+using VideoWeb.Common.Models;
+using VideoWeb.UnitTests.Builders;
+
+namespace VideoWeb.UnitTests.Common.ConferenceServiceTests
+{
+    public class RemoveConferenceTests
+    {
+        private ConferenceService _conferenceService;
+        private Conference _conference;
+        private Mock<IConferenceCache> _conferenceCacheMock;
+
+        [SetUp]
+        public void SetUp()
+        {
+            _conference = new ConferenceCacheModelBuilder().Build();
+            _conferenceCacheMock = new Mock<IConferenceCache>();
+            var videoApiClientMock = new Mock<IVideoApiClient>();
+            var bookingsApiClientMock = new Mock<IBookingsApiClient>();
+            _conferenceService = new ConferenceService(_conferenceCacheMock.Object,
+                videoApiClientMock.Object,
+                bookingsApiClientMock.Object);
+        }
+
+        [Test]
+        public async Task Should_remove_conference()
+        {
+            // Arrange & Act
+            await _conferenceService.RemoveConference(_conference);
+
+            // Assert
+            _conferenceCacheMock.Verify(x => x.RemoveConferenceAsync(_conference, default), Times.Once);
+        }
+    }
+}

VideoWeb/VideoWeb.UnitTests/Controllers/InternalEventController/HearingCancelledTests.cs

@@ -1,29 +1,45 @@
 using System;
+using System.Threading;
 using System.Threading.Tasks;
 using FluentAssertions;
 using Microsoft.AspNetCore.Mvc;
 using Moq;
 using NUnit.Framework;
+using VideoWeb.Common;
+using VideoWeb.Common.Models;
 using VideoWeb.Helpers.Interfaces;
+using VideoWeb.UnitTests.Builders;
 
 namespace VideoWeb.UnitTests.Controllers.InternalEventController
 {
     public class HearingCancelledTests : InternalEventControllerTests
     {
+        private Conference _conference;
+        private Mock<IConferenceService> _conferenceServiceMock;
+        private Mock<IHearingCancelledEventNotifier> _notifierMock;
+
+        [SetUp]
+        public void Setup()
+        {
+            _conference = new ConferenceCacheModelBuilder().Build();
+            _conferenceServiceMock = Mocker.Mock<IConferenceService>();
+            _conferenceServiceMock
+                .Setup(x => x.GetConference(It.Is<Guid>(id => id == _conference.Id), It.IsAny<CancellationToken>()))
+                .ReturnsAsync(_conference);
+            _notifierMock = Mocker.Mock<IHearingCancelledEventNotifier>();
+        }
+
         [Test]
         public async Task should_push_event()
         {
-            // Arrange
-            var hearingId = Guid.NewGuid();
-            var notifierMock = Mocker.Mock<IHearingCancelledEventNotifier>();
-
-            // Act
-            var result = await Controller.HearingCancelled(hearingId);
+            // Arrange & Act
+            var result = await Controller.HearingCancelled(_conference.Id);
 
             // Assert
             result.Should().BeOfType<NoContentResult>();
-
-            notifierMock.Verify(x => x.PushHearingCancelledEvent(hearingId), Times.Once);
+
+            _conferenceServiceMock.Verify(x => x.RemoveConference(_conference, default), Times.Once);
+            _notifierMock.Verify(x => x.PushHearingCancelledEvent(_conference), Times.Once);
         }
     }
 }