public static Conference MapConferenceToCacheModel(ConferenceDetailsResponse conferenceResponse)
{
var participants = conferenceResponse
.Participants
.Select(MapParticipantToCacheModel)
.ToList();
var endpoints = conferenceResponse.Endpoints == null
? new List <Endpoint>()
: conferenceResponse.Endpoints.Select(EndpointCacheMapper.MapEndpointToCacheModel).ToList();
var civilianRooms = conferenceResponse.CivilianRooms == null
? new List <CivilianRoom>()
: conferenceResponse.CivilianRooms.Select(CivilianRoomCacheMapper.MapCivilianRoomToCacheModel)
.ToList();
var conference = new Conference
{
Id = conferenceResponse.Id,
HearingId = conferenceResponse.HearingId,
Participants = participants,
HearingVenueName = conferenceResponse.HearingVenueName,
Endpoints = endpoints,
CivilianRooms = civilianRooms
};
return(conference);
}
public void Setup()
{
_bookingsApiClient = new Mock <IBookingsApiClient>();
_userIdentity = new Mock <IUserIdentity>();
_userAccountService = new Mock <IUserAccountService>();
_editHearingRequestValidator = new Mock <IValidator <EditHearingRequest> >();
_videoApiMock = new Mock <IVideoApiClient>();
_pollyRetryServiceMock = new Mock <IPollyRetryService>();
_notificationApiMock = new Mock <INotificationApiClient>();
_participantGroupLogger = new Mock <ILogger <HearingsService> >();
_hearingsService = new HearingsService(_pollyRetryServiceMock.Object,
_userAccountService.Object, _notificationApiMock.Object, _videoApiMock.Object, _bookingsApiClient.Object, _participantGroupLogger.Object);
_controller = new AdminWebsite.Controllers.HearingsController(_bookingsApiClient.Object,
_userIdentity.Object,
_userAccountService.Object,
_editHearingRequestValidator.Object,
new Mock <ILogger <AdminWebsite.Controllers.HearingsController> >().Object,
_hearingsService,
Mock.Of <IPublicHolidayRetriever>());
_conference = new ConferenceDetailsResponse
{
MeetingRoom = new MeetingRoomResponse
{
TelephoneConferenceId = "454545",
AdminUri = "uri",
JudgeUri = "uri",
ParticipantUri = "uri",
PexipNode = "node"
}
};
}
public static Conference MapConferenceToCacheModel(ConferenceDetailsResponse conferenceResponse)
{
var participants = conferenceResponse
.Participants
.Select(participant => new Participant
{
Id = participant.Id,
RefId = participant.Ref_id,
Name = participant.Name,
FirstName = participant.First_name,
LastName = participant.Last_name,
ContactEmail = participant.Contact_email,
ContactTelephone = participant.Contact_telephone,
DisplayName = participant.Display_name,
Role = (Role)Enum.Parse(typeof(Role), participant.User_role.ToString()),
HearingRole = participant.Hearing_role,
ParticipantStatus = (ParticipantStatus)Enum.Parse(typeof(ParticipantStatus),
participant.Current_status.ToString()),
Username = participant.Username,
CaseTypeGroup = participant.Case_type_group,
})
.ToList();
var endpoints = conferenceResponse.Endpoints == null ? new List <Endpoint>() : conferenceResponse.Endpoints.Select(EndpointCacheMapper.MapEndpointToCacheModel).ToList();
var conference = new Conference
{
Id = conferenceResponse.Id,
HearingId = conferenceResponse.Hearing_id,
Participants = participants,
HearingVenueName = conferenceResponse.Hearing_venue_name,
Endpoints = endpoints
};
return(conference);
}
public static ConferenceDetailsResponse MapConferenceToResponse(Conference conference,
string pexipSelfTestNode)
{
var allInterpreterRooms = conference.Rooms.OfType <ParticipantRoom>().ToList();
var interpreterRooms = allInterpreterRooms.Select(RoomToCivilianRoomResponseMapper.MapToResponse).ToList();
var response = new ConferenceDetailsResponse
{
Id = conference.Id,
HearingId = conference.HearingRefId,
CaseType = conference.CaseType,
CaseNumber = conference.CaseNumber,
CaseName = conference.CaseName,
ScheduledDateTime = conference.ScheduledDateTime,
StartedDateTime = conference.ActualStartTime,
ClosedDateTime = conference.ClosedDateTime,
ScheduledDuration = conference.ScheduledDuration,
CurrentStatus = conference.GetCurrentStatus().MapToContractEnum(),
Participants = MapParticipants(conference.Participants, allInterpreterRooms),
MeetingRoom = MeetingRoomToResponseMapper.MapVirtualCourtToResponse(conference.GetMeetingRoom()),
Endpoints = conference.GetEndpoints().Select(EndpointToResponseMapper.MapEndpointResponse).ToList(),
HearingVenueName = conference.HearingVenueName,
AudioRecordingRequired = conference.AudioRecordingRequired,
CivilianRooms = interpreterRooms
};
if (response.MeetingRoom != null)
{
response.MeetingRoom.PexipSelfTestNode = pexipSelfTestNode;
}
return(response);
}
protected ConferenceEventRequest CreateTransferEventRequest(ConferenceDetailsResponse conference)
{
return(new ConferenceEventRequestBuilder(conference)
.ForJudge()
.WithEventType(EventType.Transfer)
.Build());
}
protected ConferenceEventRequest CreatePrivateConsultationEventRequest(ConferenceDetailsResponse conference)
{
return(new ConferenceEventRequestBuilder(conference)
.ForIndividual()
.WithEventType(EventType.Consultation)
.Build());
}
public async Task ThenAConferenceDetailsShouldBeRetrieved()
{
_conferenceDetails = await Response.GetResponses <ConferenceDetailsResponse>(_context.Response.Content);
_conferenceDetails.Should().NotBeNull();
AssertConferenceDetailsResponse.ForConference(_conferenceDetails);
}
protected ConferenceEventRequest CreateVideoEventRequest(ConferenceDetailsResponse conference)
{
return(new ConferenceEventRequestBuilder(conference)
.ForIndividual()
.WithEventType(EventType.MediaPermissionDenied)
.Build());
}
public static ConferenceResponse MapConferenceDetailsToResponseModel(ConferenceDetailsResponse conference)
{
var response = new ConferenceResponse
{
Id = conference.Id,
CaseName = conference.Case_name,
CaseNumber = conference.Case_number,
CaseType = conference.Case_type,
ScheduledDateTime = conference.Scheduled_date_time,
ScheduledDuration = conference.Scheduled_duration,
Status = GetStatus(conference.Current_status),
Participants = MapParticipants(conference),
ClosedDateTime = conference.Closed_date_time,
HearingVenueName = conference.Hearing_venue_name,
AudioRecordingRequired = conference.Audio_recording_required,
HearingRefId = conference.Hearing_id,
Endpoints = MapEndpoints(conference)
};
if (conference.Meeting_room != null)
{
response.ParticipantUri = conference.Meeting_room.Participant_uri;
response.PexipNodeUri = conference.Meeting_room.Pexip_node;
response.PexipSelfTestNodeUri = conference.Meeting_room.Pexip_self_test_node;
ParticipantTilePositionHelper.AssignTilePositions(response.Participants);
}
return(response);
}
private static List <ParticipantResponse> MapParticipants(ConferenceDetailsResponse conference)
{
conference.Participants ??= new List <ParticipantDetailsResponse>();
return(conference.Participants
.OrderBy(x => x.Case_type_group)
.Select(ParticipantResponseMapper.MapParticipantToResponseModel)
.ToList());
}
public static void ForConference(ConferenceDetailsResponse conference)
{
conference.Should().NotBeNull();
conference.CaseType.Should().NotBeNullOrEmpty();
conference.CaseNumber.Should().NotBeNullOrEmpty();
conference.CaseName.Should().NotBeNullOrEmpty();
conference.ScheduledDuration.Should().BeGreaterThan(0);
conference.ScheduledDateTime.Should().NotBe(DateTime.MinValue);
conference.CurrentStatus.Should().NotBeNull();
conference.HearingVenueName.Should().NotBeNull();
conference.Participants.Should().NotBeNullOrEmpty();
foreach (var participant in conference.Participants)
{
participant.Name.Should().NotBeNullOrEmpty();
participant.DisplayName.Should().NotBeNullOrEmpty();
participant.Username.Should().NotBeNullOrEmpty();
participant.UserRole.Should().NotBe(UserRole.None);
participant.CaseTypeGroup.Should().NotBeNullOrEmpty();
participant.HearingRole.Should().NotBeNullOrEmpty();
participant.FirstName.Should().NotBeNullOrWhiteSpace();
participant.LastName.Should().NotBeNullOrWhiteSpace();
participant.ContactEmail.Should().NotBeNullOrWhiteSpace();
participant.CurrentStatus.Should().NotBe(ParticipantState.None);
if (participant.UserRole == UserRole.Representative)
{
participant.Representee.Should().NotBeNullOrEmpty();
}
}
conference.MeetingRoom.Should().NotBeNull();
conference.MeetingRoom.AdminUri.Should().NotBeNull();
conference.MeetingRoom.JudgeUri.Should().NotBeNull();
conference.MeetingRoom.ParticipantUri.Should().NotBeNull();
conference.MeetingRoom.PexipNode.Should().NotBeNull();
conference.MeetingRoom.TelephoneConferenceId.Should().NotBeNull();
conference.MeetingRoom.PexipSelfTestNode.Should().NotBeNullOrEmpty();
if (conference.CurrentStatus > ConferenceState.NotStarted)
{
conference.StartedDateTime.Should().HaveValue().And.NotBe(DateTime.MinValue);
}
if (conference.CurrentStatus == ConferenceState.Closed)
{
conference.ClosedDateTime.Should().HaveValue().And.NotBe(DateTime.MinValue);
}
conference.AudioRecordingRequired.Should().BeFalse();
foreach (var endpoint in conference.Endpoints)
{
endpoint.Id.Should().NotBeEmpty();
endpoint.DisplayName.Should().NotBeNullOrWhiteSpace();
endpoint.SipAddress.Should().NotBeNullOrWhiteSpace();
endpoint.Pin.Should().NotBeNullOrWhiteSpace();
}
}
public async Task ThenTheConferenceShouldBeClosed()
{
_context.Uri = GetConferenceDetailsById(_context.Test.Conference.Id);
_context.HttpMethod = HttpMethod.Get;
await _commonSteps.WhenISendTheRequestToTheEndpoint();
_conferenceDetails = await Response.GetResponses <ConferenceDetailsResponse>(_context.Response.Content);
_conferenceDetails.CurrentStatus.Should().Be(ConferenceState.Closed);
}
public async Task AddConferenceAsync(ConferenceDetailsResponse conferenceResponse)
{
var conference = ConferenceCacheMapper.MapConferenceToCacheModel(conferenceResponse);
await _memoryCache.GetOrCreateAsync(conference.Id, entry =>
{
entry.SlidingExpiration = TimeSpan.FromHours(4);
return(Task.FromResult(conference));
});
}
public static ConferenceResponse Map(ConferenceDetailsResponse response)
{
return(new ConferenceResponse()
{
Id = response.Id,
HearingRefId = response.HearingId,
Case_name = response.CaseName,
Participants = ParticipantsResponseMapper.Map(response.Participants),
Status = response.CurrentStatus
});
}
public static void ForConferenceEndpoints(ConferenceDetailsResponse conference)
{
conference.Endpoints.Should().NotBeNullOrEmpty();
foreach (var endpoint in conference.Endpoints)
{
endpoint.Id.Should().NotBeEmpty();
endpoint.DisplayName.Should().NotBeEmpty();
endpoint.SipAddress.Should().NotBeEmpty();
endpoint.Pin.Should().NotBeEmpty();
}
}
public ConferenceEventRequestBuilder(ConferenceDetailsResponse conference)
{
_conference = conference;
_request = new ConferenceEventRequest()
{
ConferenceId = conference.Id.ToString(),
EventId = Guid.NewGuid().ToString(),
Reason = HearingData.VIDEO_EVENT_REASON,
TimeStampUtc = DateTime.UtcNow
};
}
public static bool HasValidMeetingRoom(this ConferenceDetailsResponse conference)
{
if (conference?.MeetingRoom == null)
{
return(false);
}
return(!string.IsNullOrWhiteSpace(conference.MeetingRoom.AdminUri) &&
!string.IsNullOrWhiteSpace(conference.MeetingRoom.ParticipantUri) &&
!string.IsNullOrWhiteSpace(conference.MeetingRoom.JudgeUri) &&
!string.IsNullOrWhiteSpace(conference.MeetingRoom.PexipNode));
}
protected async Task ConfirmHearing()
{
var confirmRequest = new UpdateBookingStatusRequestBuilder()
.UpdatedBy(HearingData.CREATED_BY(Context.Config.UsernameStem))
.Build();
await BookingApiClient.UpdateBookingStatusAsync(Hearing.Id, confirmRequest);
Conference = await GetConferenceByHearingIdPollingAsync(Hearing.Id);
Verify.ConferenceDetailsResponse(Conference, Hearing);
}
public async Task UpdateBookingStatus_returns_false_response_when_video_api_throws()
{
_userIdentity.Setup(x => x.GetUserIdentityName()).Returns("test");
var updateCreatedStatus = new UpdateBookingStatusRequest
{
UpdatedBy = "test",
CancelReason = "",
Status = UpdateBookingStatus.Created
};
var hearingId = Guid.NewGuid();
var expectedConferenceDetailsResponse = new ConferenceDetailsResponse
{
Id = Guid.NewGuid(),
HearingId = hearingId,
MeetingRoom = new MeetingRoomResponse
{
AdminUri = "admin",
JudgeUri = "judge",
ParticipantUri = "participant",
PexipNode = "pexip"
}
};
_bookingsApiClient.Setup(x => x.UpdateBookingStatusAsync(hearingId, updateCreatedStatus));
_bookingsApiClient.Setup(x => x.UpdateBookingStatusAsync(hearingId, It.IsAny <UpdateBookingStatusRequest>()));
_pollyRetryServiceMock.Setup(x => x.WaitAndRetryAsync <VideoApiException, ConferenceDetailsResponse>
(
It.IsAny <int>(), It.IsAny <Func <int, TimeSpan> >(), It.IsAny <Action <int> >(),
It.IsAny <Func <ConferenceDetailsResponse, bool> >(), It.IsAny <Func <Task <ConferenceDetailsResponse> > >()
))
.Callback(async(int retries, Func <int, TimeSpan> sleepDuration, Action <int> retryAction,
Func <ConferenceDetailsResponse, bool> handleResultCondition, Func <Task <ConferenceDetailsResponse> > executeFunction) =>
{
sleepDuration(1);
retryAction(1);
handleResultCondition(expectedConferenceDetailsResponse);
await executeFunction();
})
.ThrowsAsync(new VideoApiException("", 0, "", null, null));
var response = await _controller.UpdateBookingStatus(hearingId, updateCreatedStatus);
var result = (OkObjectResult)response;
result.StatusCode.Should().Be(StatusCodes.Status200OK);
result.Value.Should().NotBeNull().And.BeAssignableTo <UpdateBookingStatusResponse>().Subject.Success.Should().BeFalse();
_bookingsApiClient.Verify(x => x.UpdateBookingStatusAsync(hearingId, updateCreatedStatus), Times.Once);
_bookingsApiClient.Verify(x => x.UpdateBookingStatusAsync(hearingId, It.Is <UpdateBookingStatusRequest>(pred => pred.Status == UpdateBookingStatus.Failed)), Times.Once);
}
public static void UpdatedConference(ConferenceDetailsResponse conferenceDetails, UpdateHearingRequest request)
{
conferenceDetails.Should().BeEquivalentTo(request, options => options
.Excluding(x => x.Cases)
.Excluding(x => x.HearingRoomName)
.Excluding(x => x.OtherInformation)
.Excluding(x => x.QuestionnaireNotRequired)
.Excluding(x => x.UpdatedBy)
);
conferenceDetails.CaseName.Should().Be(request.Cases.First().Name);
conferenceDetails.CaseNumber.Should().Be(request.Cases.First().Number);
}
public void InitConferenceResponse()
{
ConferenceResponse = new ConferenceDetailsResponse
{
Id = Guid.NewGuid(),
Participants = new List <ParticipantDetailsResponse>
{
new ParticipantDetailsResponse {
Id = Guid.NewGuid()
}
}
};
}
public async Task AddConferenceAsync(ConferenceDetailsResponse conferenceResponse)
{
var conference = ConferenceCacheMapper.MapConferenceToCacheModel(conferenceResponse);
var serialisedConference = JsonConvert.SerializeObject(conference, CachingHelper.SerializerSettings);
var data = Encoding.UTF8.GetBytes(serialisedConference);
await _distributedCache.SetAsync(conference.Id.ToString(), data,
new DistributedCacheEntryOptions
{
SlidingExpiration = TimeSpan.FromHours(4)
});
}
public async Task Returns_Conference_Details_Response()
{
var videoApiClientMock = new Mock <IVideoApiClient>();
var loggerMock = new Mock <ILogger <VideoApiService> >();
var videoApiService = new VideoApiService(videoApiClientMock.Object, loggerMock.Object);
var bookNewConferenceRequest = new BookNewConferenceRequest();
var conferenceDetailsResponse = new ConferenceDetailsResponse();
videoApiClientMock.Setup(x => x.BookNewConferenceAsync(It.Is <BookNewConferenceRequest>(x => x == bookNewConferenceRequest))).ReturnsAsync(conferenceDetailsResponse);
var result = await videoApiService.BookNewConferenceAsync(bookNewConferenceRequest);
Assert.AreEqual(conferenceDetailsResponse, result);
}
public void Init()
{
conferenceDetailsResp = new ConferenceDetailsResponse
{
Id = Guid.NewGuid(),
HearingId = Guid.NewGuid(),
MeetingRoom = new MeetingRoomResponse
{
AdminUri = "admin",
JudgeUri = "judge",
ParticipantUri = "participant",
PexipNode = "pexip",
TelephoneConferenceId = "121212"
}
};
}
public static void ConferenceDetailsResponse(ConferenceDetailsResponse response, HearingDetailsResponse hearing)
{
response.AudioRecordingRequired.Should().Be(hearing.AudioRecordingRequired);
response.CaseName.Should().Be(hearing.Cases.First().Name);
response.CaseNumber.Should().Be(hearing.Cases.First().Number);
response.CaseType.Should().Be(hearing.CaseTypeName);
response.ClosedDateTime.Should().BeNull();
response.CurrentStatus.Should().Be(ConferenceState.NotStarted);
response.HearingId.Should().Be(hearing.Id);
response.HearingVenueName.Should().Be(hearing.HearingVenueName);
response.Id.Should().NotBeEmpty();
response.ScheduledDateTime.Should().Be(hearing.ScheduledDateTime);
response.ScheduledDuration.Should().Be(hearing.ScheduledDuration);
response.StartedDateTime.Should().BeNull();
VerifyConferenceParticipants(response.Participants, hearing.Participants);
}
public static List <ConferenceForJudgeResponse> Map(ConferenceDetailsResponse response)
{
return(new List <ConferenceForJudgeResponse>()
{
new ConferenceForJudgeResponse()
{
CaseName = response.CaseName,
CaseNumber = response.CaseNumber,
CaseType = response.CaseType,
Id = Guid.NewGuid(),
Participants = AddParticipants(response.Participants),
ScheduledDateTime = response.ScheduledDateTime,
ScheduledDuration = response.ScheduledDuration,
Status = ConferenceState.NotStarted
}
});
}
private ConferenceDetailsResponse CreateConferenceDetailsResponse()
{
var pats = TestConference.Participants.Select(p => new ParticipantDetailsResponse
{
Id = p.Id,
Username = p.Username,
DisplayName = p.DisplayName,
}).ToList();
var conference = new ConferenceDetailsResponse
{
Id = TestConference.Id,
HearingId = TestConference.HearingId,
Participants = pats
};
return(conference);
}
private static void AssignTilePositions(ConferenceDetailsResponse conference, ConferenceResponseVho response)
{
var tiledParticipants = conference.Participants.Where(x =>
x.User_role == UserRole.Individual || x.User_role == UserRole.Representative).ToList();
var partyGroups = tiledParticipants.GroupBy(x => x.Case_type_group).ToList();
foreach (var group in partyGroups)
{
var pats = @group.ToList();
var position = partyGroups.IndexOf(@group) + 1;
foreach (var p in pats)
{
var participant = response.Participants.Find(x => x.Id == p.Id);
participant.TiledDisplayName = $"T{position};{participant.DisplayName};{participant.Id}";
position += 2;
}
}
}
public void Setup()
{
ParticipantId = Guid.NewGuid();
HearingId = Guid.NewGuid();
VideoApiServiceMock = new Mock <IVideoApiService>();
ConferenceDetailsResponse = new ConferenceDetailsResponse
{
Id = Guid.NewGuid(),
Participants = new List <ParticipantDetailsResponse>
{
new ParticipantDetailsResponse {
Id = Guid.NewGuid(), RefId = ParticipantId
}
}
};
VideoApiServiceMock.Setup(x => x.GetConferenceByHearingRefId(HearingId, It.IsAny <bool>())).ReturnsAsync(ConferenceDetailsResponse);
VideoWebServiceMock = new Mock <IVideoWebService>();
}
public static ConferenceResponseVho MapConferenceDetailsToResponseModel(ConferenceDetailsResponse conference)
{
if (!Enum.TryParse(conference.Current_status.ToString(), true, out ConferenceStatus status))
{
status = ConferenceStatus.NotStarted;
}
conference.Participants ??= new List <ParticipantDetailsResponse>();
var participants = conference.Participants
.OrderBy(x => x.Case_type_group)
.Select(ParticipantResponseForVhoMapper.MapParticipantToResponseModel)
.ToList();
var response = new ConferenceResponseVho
{
Id = conference.Id,
CaseName = conference.Case_name,
CaseNumber = conference.Case_number,
CaseType = conference.Case_type,
ScheduledDateTime = conference.Scheduled_date_time,
ScheduledDuration = conference.Scheduled_duration,
Status = status,
Participants = participants,
ClosedDateTime = conference.Closed_date_time,
HearingVenueName = conference.Hearing_venue_name
};
if (conference.Meeting_room == null)
{
return(response);
}
response.AdminIFrameUri = conference.Meeting_room.Admin_uri;
response.ParticipantUri = conference.Meeting_room.Participant_uri;
response.PexipNodeUri = conference.Meeting_room.Pexip_node;
AssignTilePositions(conference, response);
return(response);
}
