public async Task should_return_judge_joh_to_waiting_room_for_valid_conference_and_room_type()
{
var conferenceId = TestConference.Id;
var participantId = TestConference.Participants[0].Id;
var consultationRoom = new ConsultationRoom(TestConference.Id, "ConsultationRoom", VirtualCourtRoomType.JudgeJOH, false);
TestConference.Participants[0].CurrentConsultationRoom = consultationRoom;
TestConference.Participants[0].CurrentConsultationRoomId = 1;
QueryHandlerMock
.Setup(x => x.Handle <GetConferenceByIdQuery, VideoApi.Domain.Conference>(
It.Is <GetConferenceByIdQuery>(q => q.ConferenceId == TestConference.Id)))
.ReturnsAsync(TestConference);
var fromRoom = "ConsultationRoom";
var toRoom = "WaitingRoom";
var leaveConsultationRequest = new LeaveConsultationRequest
{
ConferenceId = conferenceId, ParticipantId = participantId
};
await Controller.LeaveConsultationAsync(leaveConsultationRequest);
QueryHandlerMock.Verify(q => q.Handle <GetConferenceByIdQuery, VideoApi.Domain.Conference>
(It.IsAny <GetConferenceByIdQuery>()), Times.Once);
ConsultationServiceMock.Verify(v => v.LeaveConsultationAsync
(leaveConsultationRequest.ConferenceId, leaveConsultationRequest.ParticipantId, fromRoom, toRoom),
Times.Once);
}
private async Task <LeaveConsultationRequest> SetupLeaveConsultationRequest(bool inConsultationRoom)
{
var request = new LeaveConsultationRequest
{
ConferenceId = _context.Test.Conference.Id,
ParticipantId = _context.Test.Conference.Participants[0].Id
};
if (!inConsultationRoom)
{
return(request);
}
var participantId = _context.Test.Conference.Participants[0].Id;
await using (var db = new VideoApiDbContext(_context.VideoBookingsDbContextOptions))
{
var conference = await db.Conferences
.Include("Participants")
.SingleAsync(x => x.Id == _context.Test.Conference.Id);
var room = new ConsultationRoom(_context.Test.Conference.Id, "TestRoom", VirtualCourtRoomType.Participant, false);
var participant = conference.Participants.Single(x => x.Id == participantId);
participant.UpdateCurrentRoom(RoomType.ConsultationRoom);
participant.UpdateCurrentConsultationRoom(room);
await db.SaveChangesAsync();
request.ParticipantId = participantId;
}
return(request);
}
public async Task should_return_bad_request_when_endpoint_is_already_in_room()
{
var endpointWithDefenceAdvocate = TestConference.GetEndpoints().First(x => !string.IsNullOrWhiteSpace(x.DefenceAdvocate));
var defenceAdvocate = TestConference.GetParticipants().First(x =>
x.Username.Equals(endpointWithDefenceAdvocate.DefenceAdvocate,
StringComparison.CurrentCultureIgnoreCase));
var room = new ConsultationRoom(TestConference.Id, "Label", VideoApi.Domain.Enums.VirtualCourtRoomType.Participant, false);
room.AddEndpoint(new RoomEndpoint(Guid.NewGuid()));
QueryHandlerMock.Setup(x => x.Handle <GetConsultationRoomByIdQuery, ConsultationRoom>(It.IsAny <GetConsultationRoomByIdQuery>())).ReturnsAsync(room);
var request = new EndpointConsultationRequest()
{
ConferenceId = TestConference.Id,
EndpointId = endpointWithDefenceAdvocate.Id,
RequestedById = defenceAdvocate.Id,
RoomLabel = "Label"
};
var result = await Controller.StartConsultationWithEndpointAsync(request);
var actionResult = result.As <BadRequestObjectResult>();
actionResult.Should().NotBeNull();
actionResult.Value.Should().Be("Room already has an active endpoint");
}
public void should_map_participant_to_response_wit_interpreter_room()
{
var consultationRoom = new ConsultationRoom(Guid.NewGuid(), "ParticipantRoom1",
VirtualCourtRoomType.Participant, true);
var participant = new ParticipantBuilder().WithUserRole(UserRole.Individual).Build();
participant.UpdateCurrentConsultationRoom(consultationRoom);
var interpreterRoom = new ParticipantRoom(Guid.NewGuid(), "Interpreter1", VirtualCourtRoomType.Witness);
var response = ParticipantToDetailsResponseMapper.MapParticipantToResponse(participant, interpreterRoom);
response.Should().BeEquivalentTo(participant, options => options
.Excluding(x => x.ParticipantRefId)
.Excluding(x => x.TestCallResultId)
.Excluding(x => x.TestCallResult)
.Excluding(x => x.CurrentConsultationRoomId)
.Excluding(x => x.CurrentConsultationRoom)
.Excluding(x => x.CurrentRoom)
.Excluding(x => x.State)
.Excluding(x => x.LinkedParticipants)
.Excluding(x => x.RoomParticipants));
response.CurrentInterpreterRoom.Should().NotBeNull();
response.CurrentInterpreterRoom.Id.Should().Be(interpreterRoom.Id);
response.CurrentInterpreterRoom.Label.Should().Be(interpreterRoom.Label);
response.CurrentInterpreterRoom.Locked.Should().BeFalse();
response.CurrentRoom.Should().NotBeNull();
response.CurrentRoom.Id.Should().Be(consultationRoom.Id);
response.CurrentRoom.Label.Should().Be(consultationRoom.Label);
response.CurrentRoom.Locked.Should().Be(consultationRoom.Locked);
}
public async Task should_update_participant_to_disconnected_from_virtual_room()
{
// Arrange conference with participant in consultation room
var seededConference = await TestDataManager.SeedConference();
_newConferenceIds.Add(seededConference.Id);
var consultationRoom = new ConsultationRoom(seededConference.Id, $"JudgeConsultationRoom{DateTime.UtcNow.Ticks}",
VirtualCourtRoomType.JudgeJOH, false);
var room = await TestDataManager.SeedRoom(consultationRoom);
var newRoomId = room.Id;
var pat1 = seededConference.Participants[0].Id;
await TestDataManager.SeedRoomWithRoomParticipant(newRoomId, new RoomParticipant(pat1));
// Act
var command =
new UpdateParticipantStatusAndRoomCommand(seededConference.Id, pat1, ParticipantState.Disconnected, null,
null);
await _handler.Handle(command);
// Assert
var updatedConference = await _conferenceByIdHandler.Handle(new GetConferenceByIdQuery(seededConference.Id));
var updatedParticipant = updatedConference.GetParticipants().Single(x => x.Id == pat1);
updatedParticipant.State.Should().Be(ParticipantState.Disconnected);
updatedParticipant.CurrentRoom.Should().BeNull();
updatedParticipant.CurrentConsultationRoom.Should().BeNull();
}
public async Task should_remove_a_participant_in_room()
{
var participant = TestConference.Participants[0];
var consultationRoom = new ConsultationRoom(TestConference.Id, "ConsultationRoom2", VirtualCourtRoomType.Participant, false);
consultationRoom.AddParticipant(new RoomParticipant(participant.Id));
_queryHandler.Setup(x => x.Handle <GetConsultationRoomByIdQuery, ConsultationRoom>(It.IsAny <GetConsultationRoomByIdQuery>())).ReturnsAsync(consultationRoom);
var participantId = participant.Id;
var fromRoom = consultationRoom.Label;
var toRoom = "WaitingRoom";
_queryHandler.Setup(x => x.Handle <GetConferenceByIdQuery, Conference>(It.IsAny <GetConferenceByIdQuery>()))
.ReturnsAsync(TestConference);
await _consultationService.LeaveConsultationAsync(TestConference.Id, participantId, fromRoom, toRoom);
_kinlyApiClient.Verify(x =>
x.TransferParticipantAsync(TestConference.Id.ToString(),
It.Is <TransferParticipantParams>(r =>
r.From == fromRoom &&
r.To == toRoom
)
)
, Times.Exactly(1));
}
public async Task Should_update_participant_status_and_virtual_room()
{
var seededConference = await TestDataManager.SeedConference();
_newConferenceIds.Add(seededConference.Id);
var consultationRoom = new ConsultationRoom(seededConference.Id, $"JudgeConsultationRoom{DateTime.UtcNow.Ticks}",
VirtualCourtRoomType.JudgeJOH, false);
var seededRoom = await TestDataManager.SeedRoom(consultationRoom);
TestContext.WriteLine($"New seeded conference id: {seededConference.Id}");
TestContext.WriteLine($"New seeded room id: {seededRoom.Id}");
var participant = seededConference.GetParticipants().First(p => p.IsJudge());
const ParticipantState state = ParticipantState.InConsultation;
var beforeState = participant.GetCurrentStatus();
var command = new UpdateParticipantStatusAndRoomCommand(seededConference.Id, participant.Id, state, null, seededRoom.Label);
await _handler.Handle(command);
var updatedConference = await _conferenceByIdHandler.Handle(new GetConferenceByIdQuery(seededConference.Id));
var updatedParticipant = updatedConference.GetParticipants().Single(x => x.Username == participant.Username);
var afterState = updatedParticipant.GetCurrentStatus();
afterState.Should().NotBe(beforeState);
afterState.ParticipantState.Should().Be(state);
updatedParticipant.CurrentRoom.Should().BeNull();
updatedParticipant.CurrentConsultationRoom.Label.Should().Be(seededRoom.Label);
}
public async Task <ConsultationRoom> GetAvailableConsultationRoomAsync(Guid conferenceId, VirtualCourtRoomType roomType)
{
var query = new GetAvailableConsultationRoomsByRoomTypeQuery(roomType, conferenceId);
var listOfRooms = await _queryHandler.Handle <GetAvailableConsultationRoomsByRoomTypeQuery, List <ConsultationRoom> >(query);
var room = listOfRooms?.FirstOrDefault(x => x.Type.Equals(roomType));
if (room == null)
{
var consultationRoomParams = new CreateConsultationRoomParams
{
Room_label_prefix = roomType.ToString()
};
var createConsultationRoomResponse =
await CreateConsultationRoomAsync(conferenceId.ToString(),
consultationRoomParams);
var createRoomCommand = new CreateConsultationRoomCommand(conferenceId,
createConsultationRoomResponse.Room_label,
roomType,
false);
await _commandHandler.Handle(createRoomCommand);
room = new ConsultationRoom(conferenceId, createConsultationRoomResponse.Room_label, roomType, false);
}
return(room);
}
public void should_return_interpreter_when_participant_is_in_an_interpreter_room()
{
var conferenceId = Guid.NewGuid();
var participant = new ParticipantBuilder().WithUserRole(UserRole.Individual)
.WithCaseTypeGroup("Applicant")
.Build();
var consultationRoom = new ConsultationRoom(conferenceId, "ConsultationRoom1",
VirtualCourtRoomType.Participant, false);
consultationRoom.SetProtectedProperty(nameof(consultationRoom.Id), 998);
var interpreterRoom = new ParticipantRoom(conferenceId, "Interpreter1", VirtualCourtRoomType.Civilian);
interpreterRoom.SetProtectedProperty(nameof(interpreterRoom.Id), 999);
var consultationRoomParticipant = new RoomParticipant(participant.Id)
{
Room = consultationRoom,
RoomId = consultationRoom.Id
};
var interpreterRoomParticipant = new RoomParticipant(participant.Id)
{
Room = interpreterRoom,
RoomId = interpreterRoom.Id
};
consultationRoom.AddParticipant(consultationRoomParticipant);
interpreterRoom.AddParticipant(interpreterRoomParticipant);
participant.RoomParticipants.Add(interpreterRoomParticipant);
participant.RoomParticipants.Add(consultationRoomParticipant);
participant.GetParticipantRoom().Should().Be(interpreterRoom);
}
public async Task Should_not_transfer_endpoints_out_of_room_when_last_participant_leaves_if_transferring_to_hearing()
{
var conference = TestConference;
var participantForEvent = conference.GetParticipants().First(x => x.UserRole == UserRole.Individual);
var room = new ConsultationRoom(conference.Id, "ConsultationRoom2", VirtualCourtRoomType.Participant, false);
room.AddEndpoint(new RoomEndpoint(Guid.NewGuid()));
room.AddEndpoint(new RoomEndpoint(Guid.NewGuid()));
QueryHandlerMock.Setup(x => x.Handle <GetConsultationRoomByIdQuery, ConsultationRoom>(It.IsAny <GetConsultationRoomByIdQuery>())).ReturnsAsync(room);
var callbackEvent = new CallbackEvent
{
EventType = EventType.Transfer,
EventId = Guid.NewGuid().ToString(),
ConferenceId = conference.Id,
ParticipantId = participantForEvent.Id,
TransferFrom = null,
TransferTo = RoomType.HearingRoom,
TransferredFromRoomLabel = "ConsultationRoom2",
TransferredToRoomLabel = RoomType.HearingRoom.ToString(),
TimeStampUtc = DateTime.UtcNow
};
await _sut.HandleAsync(callbackEvent);
CommandHandlerMock.Verify(
x => x.Handle(It.Is <UpdateParticipantStatusAndRoomCommand>(command =>
command.ConferenceId == conference.Id &&
command.ParticipantId == participantForEvent.Id &&
command.ParticipantState == ParticipantState.InHearing &&
command.Room == RoomType.HearingRoom &&
command.RoomLabel == RoomType.HearingRoom.ToString())), Times.Once);
_mocker.Mock <IConsultationService>().Verify(x => x.EndpointTransferToRoomAsync(conference.Id, It.IsAny <Guid>(), RoomType.WaitingRoom.ToString()), Times.Never);
}
public async Task Should_Return_BadRequest_When_Participant_Cannot_Be_Found_In_Consultation_Room()
{
var conferenceId = TestConference.Id;
var participantId = TestConference.Participants[0].Id;
var consultationRoom = new ConsultationRoom(TestConference.Id, "ConsultationRoom", VirtualCourtRoomType.JudgeJOH, false);
TestConference.Participants[0].CurrentConsultationRoom = consultationRoom;
var fromRoom = "ConsultationRoom";
var toRoom = "WaitingRoom";
var leaveConsultationRequest = new LeaveConsultationRequest
{
ConferenceId = conferenceId, ParticipantId = participantId
};
var kinlyApiException = new KinlyApiException("", (int)HttpStatusCode.BadRequest, "payload",
new Dictionary <string, IEnumerable <string> >(), new Exception());
ConsultationServiceMock.Setup(x => x.LeaveConsultationAsync(leaveConsultationRequest.ConferenceId,
leaveConsultationRequest.ParticipantId, fromRoom, toRoom)).ThrowsAsync(kinlyApiException);
var result = await Controller.LeaveConsultationAsync(leaveConsultationRequest);
QueryHandlerMock.Verify(q => q.Handle <GetConferenceByIdQuery, VideoApi.Domain.Conference>
(It.IsAny <GetConferenceByIdQuery>()), Times.Once);
ConsultationServiceMock.Verify(v => v.LeaveConsultationAsync
(leaveConsultationRequest.ConferenceId, leaveConsultationRequest.ParticipantId, fromRoom, toRoom),
Times.Never);
result.Should().BeOfType <BadRequestObjectResult>();
}
public async Task GivenIHaveADynamicConsultationRoom()
{
var conference = _context.Test.Conference;
var consultationRoom = new ConsultationRoom(conference.Id, $"JudgeConsultationRoom{DateTime.UtcNow.Ticks}",
VirtualCourtRoomType.JudgeJOH, false);
_context.Test.Room = await _context.TestDataManager.SeedRoom(consultationRoom);
}
public async Task <ConsultationRoom> SeedRoom(ConsultationRoom consultationRoom)
{
await using var db = new VideoApiDbContext(_dbContextOptions);
await db.Rooms.AddAsync(consultationRoom);
await db.SaveChangesAsync();
return(consultationRoom);
}
public void Should_add_endpoint_to_room()
{
var endpointId = Guid.NewGuid();
var roomEndpoint = new RoomEndpoint(endpointId);
var room = new ConsultationRoom(Guid.NewGuid(), "Room1", VirtualCourtRoomType.Participant, false);
room.AddEndpoint(roomEndpoint);
room.RoomEndpoints.Count.Should().Be(1);
room.RoomEndpoints[0].EndpointId.Should().Be(endpointId);
}
public void Should_add_participant_to_room()
{
var participantId = Guid.NewGuid();
var roomParticipant = new RoomParticipant(participantId);
var room = new ConsultationRoom(Guid.NewGuid(), "Room1", VirtualCourtRoomType.JudgeJOH, false);
room.AddParticipant(roomParticipant);
room.RoomParticipants.Count.Should().Be(1);
room.RoomParticipants[0].ParticipantId.Should().Be(participantId);
}
private List <ConsultationRoom> CreateTestRooms(StartConsultationRequest request)
{
var rooms = new List <ConsultationRoom>();
var room1 = new ConsultationRoom(request.ConferenceId, "Judge", request.RoomType.MapToDomainEnum(), false);
var room2 = new ConsultationRoom(Guid.NewGuid(), "Waiting", VirtualCourtRoomType.JudgeJOH, false);
rooms.Add(room1);
rooms.Add(room2);
return(rooms);
}
public void should_not_update_room_status_to_closed_when_room_type_is_JudicialShared()
{
var room = new ConsultationRoom(Guid.NewGuid(), "PanelMember1", VirtualCourtRoomType.JudicialShared, false);
var roomParticipant = new RoomParticipant(Guid.NewGuid());
room.AddParticipant(roomParticipant);
room.Status.Should().Be(RoomStatus.Live);
room.RemoveParticipant(roomParticipant);
room.Status.Should().Be(RoomStatus.Live);
}
public void should_not_update_room_status_to_closed_when_room_type_is_civilian()
{
var room = new ConsultationRoom(Guid.NewGuid(), "Room1", VirtualCourtRoomType.Civilian, false);
var roomParticipant = new RoomParticipant(Guid.NewGuid());
room.AddParticipant(roomParticipant);
room.Status.Should().Be(RoomStatus.Live);
room.RemoveParticipant(roomParticipant);
room.Status.Should().Be(RoomStatus.Live);
}
public void Should_create_room_and_set_status_to_created()
{
var conferenceId = Guid.NewGuid();
var label = "Interpreter1";
var room = new ConsultationRoom(conferenceId, label, VirtualCourtRoomType.JudgeJOH, false);
room.Status.Should().Be(RoomStatus.Live);
room.ConferenceId.Should().Be(conferenceId);
room.Label.Should().Be(label);
room.Type.Should().Be(VirtualCourtRoomType.JudgeJOH);
}
public void Should_update_room_status_to_closed_on_last_endpoint_remove()
{
var room = new ConsultationRoom(Guid.NewGuid(), "Room1", VirtualCourtRoomType.Participant, false);
var roomEndpoint = new RoomEndpoint(Guid.NewGuid());
room.RoomEndpoints.Add(roomEndpoint);
room.Status.Should().Be(RoomStatus.Live);
room.RemoveEndpoint(roomEndpoint);
room.Status.Should().Be(RoomStatus.Closed);
}
public void Should_remove_endpoint_from_room()
{
var endpointId = Guid.NewGuid();
var roomEndpoint = new RoomEndpoint(endpointId);
var room = new ConsultationRoom(Guid.NewGuid(), "Room1", VirtualCourtRoomType.Participant, false);
room.AddEndpoint(roomEndpoint);
var beforeCount = room.RoomEndpoints.Count;
room.RemoveEndpoint(roomEndpoint);
room.RoomEndpoints.Count.Should().Be(beforeCount - 1);
}
public void Should_remove_participant_from_room()
{
var participantId = Guid.NewGuid();
var roomParticipant = new RoomParticipant(participantId);
var room = new ConsultationRoom(Guid.NewGuid(), "Room1", VirtualCourtRoomType.JudgeJOH, false);
room.AddParticipant(roomParticipant);
var beforeCount = room.RoomParticipants.Count;
room.RemoveParticipant(roomParticipant);
room.RoomParticipants.Count.Should().Be(beforeCount - 1);
}
public void Should_not_add_existing_endpoint_to_room_twice()
{
var endpointId = Guid.NewGuid();
var roomEndpoint = new RoomEndpoint(endpointId);
var room = new ConsultationRoom(Guid.NewGuid(), "Room1", VirtualCourtRoomType.Participant, false);
room.AddEndpoint(roomEndpoint);
var beforeCount = room.RoomEndpoints.Count;
room.AddEndpoint(roomEndpoint);
room.RoomEndpoints.Count.Should().Be(beforeCount);
}
public void Should_update_current_room()
{
var participant = new ParticipantBuilder().WithUserRole(UserRole.Individual)
.WithCaseTypeGroup("Applicant")
.Build();
participant.CurrentConsultationRoom.Should().BeNull();
var newRoom = new ConsultationRoom(Guid.NewGuid(), "TestRoom1", VirtualCourtRoomType.JudgeJOH, false);
participant.UpdateCurrentConsultationRoom(newRoom);
participant.CurrentConsultationRoom.Should().Be(newRoom);
}
public async Task should_not_transfer_linked_participant_out_of_consultation_when_non_linked_participants_are_still_in_consultation()
{
// arrange
var conference = new ConferenceBuilder()
.WithParticipant(UserRole.Judge, null)
.WithParticipant(UserRole.Individual, "Applicant")
.WithLinkedParticipant(UserRole.Individual, "Applicant")
.WithParticipant(UserRole.Representative, "Respondent")
.WithInterpreterRoom()
.Build();
var interpreterRoom = conference.Rooms.OfType <ParticipantRoom>().First();
var participant = conference.Participants.First(x => !x.IsJudge() && x.GetParticipantRoom() == null);
var consultationRoom = new ConsultationRoom(conference.Id, "ConsultationRoom2", VirtualCourtRoomType.Participant, false);
foreach (var p in conference.Participants.Where(x => !x.IsJudge()))
{
consultationRoom.AddParticipant(new RoomParticipant(p.Id));
}
_mocker.Mock <IQueryHandler>().Setup(x => x.Handle <GetConferenceByIdQuery, Conference>(
It.Is <GetConferenceByIdQuery>(q => q.ConferenceId == conference.Id)))
.ReturnsAsync(conference);
_mocker.Mock <IQueryHandler>().Setup(x => x.Handle <GetConsultationRoomByIdQuery, ConsultationRoom>(It.IsAny <GetConsultationRoomByIdQuery>())).ReturnsAsync(consultationRoom);
// act
await _sut.LeaveConsultationAsync(conference.Id, participant.Id, consultationRoom.Label,
RoomType.WaitingRoom.ToString());
// assert
_mocker.Mock <IKinlyApiClient>().Verify(x =>
x.TransferParticipantAsync(conference.Id.ToString(),
It.Is <TransferParticipantParams>(r =>
r.From == consultationRoom.Label &&
r.To == RoomType.WaitingRoom.ToString() &&
r.Part_id == participant.Id.ToString())
)
, Times.Once);
_mocker.Mock <IKinlyApiClient>().Verify(x =>
x.TransferParticipantAsync(conference.Id.ToString(),
It.Is <TransferParticipantParams>(r =>
r.From == consultationRoom.Label &&
r.To == RoomType.WaitingRoom.ToString() &&
r.Part_id == interpreterRoom.Id.ToString())
)
, Times.Never);
}
public async Task <ConsultationRoom> CreateNewConsultationRoomAsync(Guid conferenceId, VirtualCourtRoomType roomType = VirtualCourtRoomType.Participant, bool locked = false)
{
var consultationRoomParams = new CreateConsultationRoomParams
{
Room_label_prefix = roomType.ToString()
};
var createConsultationRoomResponse = await CreateConsultationRoomAsync(conferenceId.ToString(), consultationRoomParams);
var createRoomCommand = new CreateConsultationRoomCommand(conferenceId, createConsultationRoomResponse.Room_label, roomType, locked);
await _commandHandler.Handle(createRoomCommand);
var room = new ConsultationRoom(conferenceId, createConsultationRoomResponse.Room_label, roomType, locked);
return(room);
}
public void Should_return_list_of_participant_in_a_room()
{
var participantId = Guid.NewGuid();
var roomParticipant = new RoomParticipant(participantId);
var room = new ConsultationRoom(Guid.NewGuid(), "Room1", VirtualCourtRoomType.JudgeJOH, false);
room.AddParticipant(roomParticipant);
room.RoomParticipants.Count.Should().Be(1);
room.RoomParticipants[0].ParticipantId.Should().Be(participantId);
var participantsList = room.GetRoomParticipants();
participantsList.Count.Should().Be(1);
}
private StartConsultationRequest RequestBuilder()
{
if (TestConference.Participants == null)
{
Assert.Fail("No participants found in conference");
}
_testConsultationRoom = new ConsultationRoom(TestConference.Id, "JohRoom1", VirtualCourtRoomType.JudgeJOH.MapToDomainEnum(), false);
return(new StartConsultationRequest
{
ConferenceId = TestConference.Id,
RequestedBy = TestConference.GetParticipants().First(x =>
x.UserRole.MapToContractEnum().Equals(UserRole.Judge)).Id,
RoomType = VirtualCourtRoomType.JudgeJOH
});
}
public async Task GivenTheJudgeJohIsInTheConsultationRoom()
{
var conferenceResponse = await Response.GetResponses <ConferenceDetailsResponse>(_context.Response.Content);
var judgeResponse =
conferenceResponse.Participants.First(x => x.UserRole == Contract.Enums.UserRole.Judge);
var consultationRoom = new ConsultationRoom(conferenceResponse.Id, "name", VirtualCourtRoomType.JudgeJOH, false);
await using var db = new VideoApiDbContext(_context.VideoBookingsDbContextOptions);
var conference = await db.Conferences
.Include(x => x.Participants)
.SingleAsync(x => x.Id == conferenceResponse.Id);
var judge = conference.Participants.First(x => x.Id == judgeResponse.Id);
judge.UpdateCurrentConsultationRoom(consultationRoom);
await db.SaveChangesAsync();
}
private async Task <ConsultationRoom> GetTransferToConsultationRoom(UpdateParticipantStatusAndRoomCommand command)
{
if (command.ParticipantState != ParticipantState.InConsultation)
{
return(null);
}
var transferToRoom = await _context.Rooms.OfType <ConsultationRoom>().SingleOrDefaultAsync(x => x.Label == command.RoomLabel && x.ConferenceId == command.ConferenceId).ConfigureAwait(true);
if (transferToRoom == null)
{
// The only way for the room not to have been created by us (where it would already be in the table) is by kinly via a VHO consultation.
var vhoConsultation = new ConsultationRoom(command.ConferenceId, command.RoomLabel, VirtualCourtRoomType.Participant, false);
_context.Rooms.Add(vhoConsultation);
transferToRoom = vhoConsultation;
}
return(transferToRoom);
}
