private async Task <Guid> CreateConferenceAsync(BookNewConferenceRequest request, string ingestUrl)
{
var existingConference = await _queryHandler.Handle <CheckConferenceOpenQuery, Conference>(
new CheckConferenceOpenQuery(request.ScheduledDateTime, request.CaseNumber, request.CaseName));
if (existingConference != null)
{
return(existingConference.Id);
}
var participants = request.Participants.Select(x =>
new Participant(x.ParticipantRefId, x.Name, x.FirstName, x.LastName, x.DisplayName, x.Username,
x.UserRole, x.HearingRole, x.CaseTypeGroup, x.ContactEmail, x.ContactTelephone)
{
Representee = x.Representee
})
.ToList();
var endpoints = request.Endpoints
.Select(x => new Endpoint(x.DisplayName, x.SipAddress, x.Pin, x.DefenceAdvocate)).ToList();
var createConferenceCommand = new CreateConferenceCommand
(
request.HearingRefId, request.CaseType, request.ScheduledDateTime, request.CaseNumber,
request.CaseName, request.ScheduledDuration, participants, request.HearingVenueName,
request.AudioRecordingRequired, ingestUrl, endpoints
);
await _commandHandler.Handle(createConferenceCommand);
return(createConferenceCommand.NewConferenceId);
}
public BookConferenceRequestBuilder(List <UserDto> users, TestType testType)
{
_request = new BookNewConferenceRequest();
_randomNumber = new Random();
_users = users;
_testType = testType;
_request.CaseType = HearingData.CASE_TYPE_NAME;
}
public Task <ConferenceDetailsResponse> BookNewConferenceAsync(BookNewConferenceRequest request)
{
BookNewConferenceCount++;
if (ConferenceResponse == null)
{
InitConferenceResponse();
}
return(Task.FromResult(ConferenceResponse));
}
public void TestInitialize()
{
_request = new BookNewConferenceRequestBuilder("Video Api Unit Test Hearing")
.WithJudge()
.WithRepresentative().WithIndividual()
.WithRepresentative("Respondent").WithIndividual("Respondent")
.WithEndpoint("DisplayName1", "1234567890", "1234")
.WithEndpoint("DisplayName2", "0987654321", "5678")
.Build();
}
public async Task <IActionResult> BookNewConferenceAsync(BookNewConferenceRequest request)
{
_logger.LogDebug("BookNewConference");
foreach (var participant in request.Participants)
{
participant.Username = participant.Username.ToLower().Trim();
participant.Name = participant.Name.Trim();
participant.FirstName = participant.FirstName.Trim();
participant.LastName = participant.LastName.Trim();
participant.DisplayName = participant.DisplayName.Trim();
}
var createAudioRecordingResponse = await CreateAudioApplicationWithRetryAsync(request);
if (!createAudioRecordingResponse.Success)
{
return(StatusCode((int)createAudioRecordingResponse.StatusCode, createAudioRecordingResponse.Message));
}
var conferenceId = await CreateConferenceWithRetiesAsync(request, createAudioRecordingResponse.IngestUrl);
_logger.LogDebug("Conference Created");
var conferenceEndpoints =
await _queryHandler.Handle <GetEndpointsForConferenceQuery, IList <Endpoint> >(
new GetEndpointsForConferenceQuery(conferenceId));
var endpointDtos = conferenceEndpoints.Select(EndpointMapper.MapToEndpoint);
var kinlyBookedSuccess = await BookKinlyMeetingRoomWithRetriesAsync(conferenceId, request.AudioRecordingRequired,
createAudioRecordingResponse.IngestUrl, endpointDtos);
if (!kinlyBookedSuccess)
{
var message = $"Could not book and find kinly meeting room for conferenceId: {conferenceId}";
_logger.LogError(message);
return(StatusCode((int)HttpStatusCode.InternalServerError, message));
}
_logger.LogDebug("Kinly Room Booked");
var getConferenceByIdQuery = new GetConferenceByIdQuery(conferenceId);
var queriedConference =
await _queryHandler.Handle <GetConferenceByIdQuery, Conference>(getConferenceByIdQuery);
var response =
ConferenceToDetailsResponseMapper.MapConferenceToResponse(queriedConference,
_kinlyConfiguration.PexipSelfTestNode);
_logger.LogInformation("Created conference {ResponseId} for hearing {HearingRefId}", response.Id, request.HearingRefId);
return(CreatedAtAction("GetConferenceDetailsById", new { conferenceId = response.Id }, response));
}
private async Task <Guid> CreateConferenceWithRetiesAsync(BookNewConferenceRequest request, string ingestUrl)
{
var result = await _pollyRetryService.WaitAndRetryAsync <Exception, Guid>
(
3,
_ => TimeSpan.FromSeconds(10),
retryAttempt => _logger.LogWarning("Failed to CreateConferenceAsync. Retrying attempt {RetryAttempt}", retryAttempt),
callResult => callResult == Guid.Empty,
async() => await CreateConferenceAsync(request, ingestUrl));
return(result);
}
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 async Task <IActionResult> BookNewConference(BookNewConferenceRequest request)
{
_logger.LogDebug($"BookNewConference");
try
{
var response = await _videoApiClient.BookNewConferenceAsync(request);
return(Created(nameof(BookNewConference), response));
}
catch (VideoApiException e)
{
return(StatusCode(e.StatusCode, e.Response));
}
}
protected async Task <ConferenceDetailsResponse> CreateConference(BookNewConferenceRequest request)
{
var uri = ApiUriFactory.ConferenceEndpoints.CreateConference;
await SendPostRequest(uri, RequestHelper.Serialise(request));
VerifyResponse(HttpStatusCode.Created, true);
var response = RequestHelper.Deserialise <ConferenceDetailsResponse>(Json);
response.Should().NotBeNull();
ConferencesToDelete.Add(response);
return(response);
}
public BookNewConferenceRequestBuilder(string caseName)
{
var fromRandomNumber = new Random();
_bookNewConferenceRequest = Builder <BookNewConferenceRequest> .CreateNew()
.With(x => x.HearingRefId = Guid.NewGuid())
.With(x => x.CaseType = "Civil Money Claims")
.With(x => x.ScheduledDateTime = DateTime.Now.ToLocalTime().AddMinutes(2))
.With(x => x.CaseNumber = $"{GenerateRandom.CaseNumber(fromRandomNumber)}")
.With(x => x.CaseName = $"{caseName} {GenerateRandom.Letters(fromRandomNumber)}")
.With(x => x.ScheduledDuration = 120)
.With(x => x.Participants = new List <ParticipantRequest>())
.With(x => x.AudioRecordingRequired = false)
.With(x => x.Endpoints = new List <AddEndpointRequest>())
.Build();
}
public static BookNewConferenceRequest MapToBookNewConferenceRequest(HearingDto hearingDto,
IEnumerable <ParticipantDto> participantDtos,
IEnumerable <EndpointDto> endpointDtos)
{
var participants = participantDtos
.Select(ParticipantToParticipantRequestMapper.MapToParticipantRequest)
.ToList();
var request = new BookNewConferenceRequest
{
CaseNumber = hearingDto.CaseNumber,
CaseName = hearingDto.CaseName,
CaseType = hearingDto.CaseType,
ScheduledDuration = hearingDto.ScheduledDuration,
ScheduledDateTime = hearingDto.ScheduledDateTime,
HearingRefId = hearingDto.HearingId,
Participants = participants,
HearingVenueName = hearingDto.HearingVenueName,
AudioRecordingRequired = hearingDto.RecordAudio,
Endpoints = endpointDtos.Select(EndpointToRequestMapper.MapToRequest).ToList()
};
return(request);
}
public ConferenceDetailsResponseBuilder(BookNewConferenceRequest request)
{
_response = new ConferenceDetailsResponse();
_request = request;
}
public Task <ConferenceDetailsResponse> BookNewConferenceAsync(BookNewConferenceRequest request)
{
_logger.LogInformation("Booking new conference for hearing {Hearing}", request.HearingRefId);
return(_apiClient.BookNewConferenceAsync(request));
}
private async Task <AudioPlatformServiceResponse> CreateAudioApplicationWithRetryAsync(BookNewConferenceRequest request)
{
var result = await _pollyRetryService.WaitAndRetryAsync <Exception, AudioPlatformServiceResponse>
(
3,
_ => TimeSpan.FromSeconds(10),
retryAttempt => _logger.LogWarning("Failed to CreateAudioApplicationAsync. Retrying attempt {RetryAttempt}", retryAttempt),
callResult => callResult == null || !callResult.Success,
() => _audioPlatformService.CreateAudioApplicationAsync(request.HearingRefId)
);
return(result);
}
public static void ConferencesForVhoResponses(List <ConferenceForAdminResponse> response, BookNewConferenceRequest request)
{
response.Count.Should().BeGreaterThan(0);
var conference = response.First(x => x.HearingRefId.Equals(request.HearingRefId));
conference.Should().BeEquivalentTo(request, options => options.ExcludingMissingMembers());
}
public static void ConferenceDetailsResponse(ConferenceDetailsResponse response, BookNewConferenceRequest request)
{
response.Should().BeEquivalentTo(request, options => options.ExcludingMissingMembers());
}
public Task BookNewConferenceAsync(BookNewConferenceRequest request)
{
BookNewConferenceCount++;
return(Task.FromResult(HttpStatusCode.OK));
}
