public async Task <IActionResult> AddSelfTestFailureEventToConferenceAsync(Guid conferenceId,
[FromBody] AddSelfTestFailureEventRequest addSelfTestFailureEventRequest)
{
var participantId = await GetIdForParticipantByUsernameInConference(conferenceId);
try
{
var eventRequest = new ConferenceEventRequest
{
Conference_id = conferenceId.ToString(),
Participant_id = participantId.ToString(),
Event_id = Guid.NewGuid().ToString(),
Event_type = addSelfTestFailureEventRequest.EventType,
Time_stamp_utc = DateTime.UtcNow,
Reason = $"Failed self-test ({addSelfTestFailureEventRequest.SelfTestFailureReason.DescriptionAttr()})"
};
await _videoApiClient.RaiseVideoEventAsync(eventRequest);
return(NoContent());
}
catch (VideoApiException e)
{
return(StatusCode(e.StatusCode, e.Response));
}
}
/// <summary>
/// This updates the VMRs for a conference when a participant joins or leaves a VMR
/// </summary>
/// <param name="conference"></param>
/// <param name="request"></param>
/// <returns></returns>
private async Task UpdateConferenceRoomParticipants(Conference conference, ConferenceEventRequest request)
{
if (!request.IsParticipantAndVmrEvent())
{
return;
}
var roomId = long.Parse(request.ParticipantRoomId);
var participantId = Guid.Parse(request.ParticipantId);
switch (request.EventType)
{
case EventType.Joined:
conference.AddParticipantToRoom(roomId, participantId);
break;
case EventType.Disconnected:
await _consultationResponseTracker.ClearResponses(conference, participantId);
conference.RemoveParticipantFromRoom(roomId, participantId);
break;
default: return;
}
await _conferenceCache.UpdateConferenceAsync(conference);
}
public async Task Should_not_create_video_event_with_invalid_request()
{
var conferenceRequest = CreateConferenceRequest();
var conference = await CreateConference(conferenceRequest);
const EventType EVENT_TYPE = EventType.None;
const int EVENT_TYPE_ID = (int)EVENT_TYPE;
var participant = conference.Participants.First(x => x.UserRole == UserRole.Individual);
var request = new ConferenceEventRequest()
{
ConferenceId = conference.Id.ToString(),
EventId = EVENT_TYPE_ID.ToString(),
EventType = EVENT_TYPE,
ParticipantId = participant.Id.ToString(),
Phone = string.Empty,
Reason = HearingData.VIDEO_EVENT_REASON,
TimeStampUtc = DateTime.UtcNow,
TransferFrom = null,
TransferTo = null
};
var uri = ApiUriFactory.ConferenceEndpoints.CreateVideoEvent;
await SendPostRequest(uri, RequestHelper.Serialise(request));
VerifyResponse(HttpStatusCode.BadRequest, false);
}
public static bool ShouldSkipEventHandler(this ConferenceEventRequest conferenceEvent) => !string.IsNullOrEmpty(conferenceEvent.Phone) || conferenceEvent.EventType == EventType.ConnectingToConference || conferenceEvent.EventType == EventType.ConnectingToEventHub || conferenceEvent.EventType == EventType.CountdownFinished || conferenceEvent.EventType == EventType.Help || conferenceEvent.EventType == EventType.SelectingMedia;
protected async Task CreateEvent(ConferenceEventRequest request)
{
var uri = ApiUriFactory.ConferenceEndpoints.CreateVideoEvent;
await SendPostRequest(uri, RequestHelper.Serialise(request));
VerifyResponse(HttpStatusCode.NoContent, true);
}
private static void GetRoomTypeEnums(ConferenceEventRequest request, out RoomType?transferTo,
out RoomType?transferFrom)
{
var isTransferFromEnum = Enum.TryParse(request.TransferFrom, out RoomType transferFromEnum);
var isTransferToEnum = Enum.TryParse(request.TransferTo, out RoomType transferToEnum);
transferFrom = isTransferFromEnum ? transferFromEnum : (RoomType?)null;
transferTo = isTransferToEnum ? transferToEnum : (RoomType?)null;
}
public ConferenceEventRequestBuilder()
{
_request = new ConferenceEventRequest()
{
EventId = Guid.NewGuid().ToString(),
Reason = "Automated",
TimeStampUtc = DateTime.UtcNow,
TransferFrom = RoomType.WaitingRoom,
TransferTo = RoomType.WaitingRoom
};
}
public static bool IsParticipantAVmr(this ConferenceEventRequest request, Conference conference,
out long roomId)
{
if (!long.TryParse(request.ParticipantId, out roomId))
{
return(false);
}
var id = roomId;
return(conference.CivilianRooms.Any(x => x.Id == id));
}
public ConferenceEventRequestBuilder()
{
_request = new ConferenceEventRequest()
{
ConferenceId = Guid.NewGuid().ToString(),
EventId = Guid.NewGuid().ToString(),
ParticipantId = Guid.NewGuid().ToString(),
Reason = HearingData.VIDEO_EVENT_REASON,
TimeStampUtc = DateTime.UtcNow
};
}
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
};
}
private Task SendEventToVideoApi(ConferenceEventRequest request)
{
if (request.EventType == EventType.VhoCall)
{
return(Task.CompletedTask);
}
request = request.UpdateEventTypeForVideoApi();
_logger.LogTrace("Raising video event: ConferenceId: {ConferenceId}, EventType: {EventType}",
request.ConferenceId, request.EventType);
return(_videoApiClient.RaiseVideoEventAsync(request));
}
public async Task <IActionResult> CreateEvent(ConferenceEventRequest request)
{
_logger.LogDebug($"CreateEvent");
try
{
await _videoApiClient.RaiseVideoEventAsync(request);
return(NoContent());
}
catch (VideoApiException e)
{
return(StatusCode(e.StatusCode, e.Response));
}
}
public static ConferenceEventRequest UpdateEventTypeForVideoApi(this ConferenceEventRequest request)
{
request.EventType = request.EventType switch
{
EventType.Joined when !request.ParticipantRoomId.IsNullOrEmpty() => EventType
.RoomParticipantJoined,
EventType.Disconnected when !request.ParticipantRoomId.IsNullOrEmpty() => EventType
.RoomParticipantDisconnected,
EventType.Transfer when !request.ParticipantRoomId.IsNullOrEmpty() => EventType
.RoomParticipantTransfer,
_ => request.EventType
};
return(request);
}
}
private CallbackEvent TransformAndMapRequest(ConferenceEventRequest request, Conference conference)
{
var isPhoneEvent = string.IsNullOrEmpty(request.Phone);
if (!isPhoneEvent)
{
return(null);
}
var callbackEventMapper = _mapperFactory.Get <ConferenceEventRequest, Conference, CallbackEvent>();
var callbackEvent = callbackEventMapper.Map(request, conference);
request.EventType = Enum.Parse <EventType>(callbackEvent.EventType.ToString());
return(callbackEvent);
}
public async Task <IActionResult> CreateVideoEvent(ConferenceEventRequest request)
{
_logger.LogDebug("CreateVideoEvent");
try
{
await _testApiClient.CreateEventAsync(request);
return(NoContent());
}
catch (TestApiException e)
{
_logger.LogError(e, "Unable to create event: {eventType}", request.EventType);
return(StatusCode(e.StatusCode, e.Response));
}
}
public async Task <IActionResult> UpdateParticipantStatusAsync(Guid conferenceId,
UpdateParticipantStatusEventRequest updateParticipantStatusEventRequest)
{
var conference = await _conferenceCache.GetOrAddConferenceAsync(conferenceId, () =>
{
_logger.LogTrace($"Retrieving conference details for conference: ${conferenceId}");
return(_videoApiClient.GetConferenceDetailsByIdAsync(conferenceId));
});
var username = User.Identity.Name;
var participantId = GetIdForParticipantByUsernameInConference(conference, username);
var conferenceEventRequest = new ConferenceEventRequest
{
Conference_id = conferenceId.ToString(),
Participant_id = participantId.ToString(),
Event_id = Guid.NewGuid().ToString(),
Event_type = updateParticipantStatusEventRequest.EventType,
Time_stamp_utc = DateTime.UtcNow,
Reason = EventTypeReasonMapper.Map(updateParticipantStatusEventRequest.EventType)
};
var callbackEvent =
CallbackEventMapper.MapConferenceEventToCallbackEventModel(conferenceEventRequest, conference);
var handler = _eventHandlerFactory.Get(callbackEvent.EventType);
try
{
await handler.HandleAsync(callbackEvent);
}
catch (ConferenceNotFoundException)
{
return(BadRequest());
}
try
{
await _videoApiClient.RaiseVideoEventAsync(conferenceEventRequest);
return(NoContent());
}
catch (VideoApiException e)
{
return(StatusCode(e.StatusCode, e.Response));
}
}
public ConferenceControllerTests()
{
_loggerMock = new Mock <ILogger <ConferencesController> >();
_controller = new ConferencesController(_testApiClientMock.Object, _loggerMock.Object);
_request = new ConferenceEventRequest()
{
ConferenceId = Guid.NewGuid().ToString(),
EventId = Guid.NewGuid().ToString(),
EventType = EventsData.EVENT_TYPE,
ParticipantId = Guid.NewGuid().ToString(),
Phone = EventsData.PHONE,
Reason = EventsData.REASON,
TimeStampUtc = DateTime.UtcNow,
TransferFrom = EventsData.TRANSFER_FROM,
TransferTo = EventsData.TRANSFER_TO
};
}
public async Task <IActionResult> UpdateParticipantStatusAsync(Guid conferenceId,
UpdateParticipantStatusEventRequest updateParticipantStatusEventRequest)
{
var conference = await _conferenceCache.GetOrAddConferenceAsync(conferenceId,
() => _videoApiClient.GetConferenceDetailsByIdAsync(conferenceId));
var participantId = GetIdForParticipantByUsernameInConference(conference);
var eventTypeMapper = _mapperFactory.Get <EventType, string>();
var conferenceEventRequest = new ConferenceEventRequest
{
ConferenceId = conferenceId.ToString(),
ParticipantId = participantId.ToString(),
EventId = Guid.NewGuid().ToString(),
EventType = updateParticipantStatusEventRequest.EventType,
TimeStampUtc = DateTime.UtcNow,
Reason = eventTypeMapper.Map(updateParticipantStatusEventRequest.EventType)
};
var callbackEventMapper = _mapperFactory.Get <ConferenceEventRequest, Conference, CallbackEvent>();
var callbackEvent = callbackEventMapper.Map(conferenceEventRequest, conference);
var handler = _eventHandlerFactory.Get(callbackEvent.EventType);
try
{
await handler.HandleAsync(callbackEvent);
}
catch (ConferenceNotFoundException e)
{
_logger.LogError(e, $"Unable to retrieve conference details");
return(BadRequest(e));
}
try
{
await _videoApiClient.RaiseVideoEventAsync(conferenceEventRequest);
return(NoContent());
}
catch (VideoApiException e)
{
_logger.LogError(e, $"Unable to update participant status for " +
$"participant: {participantId} in conference: {conferenceId}");
return(StatusCode(e.StatusCode, e.Response));
}
}
public async Task PostEventAsync_FireEvent(EventType eventType, bool shouldHandleEvent)
{
// Arrange
var conferenceEventRequest = new ConferenceEventRequest
{
EventType = eventType
};
_mocker.Mock <IEventHandlerFactory>().Setup(x => x.Get(It.IsAny <EventType>())).Returns(_mocker.Mock <IEventHandler>().Object);
// Act
await _sut.PostEventAsync(conferenceEventRequest);
// Assert
_mocker.Mock <ICommandHandler>().Verify(x => x.Handle(It.IsAny <SaveEventCommand>()), Times.Once);
_mocker.Mock <IEventHandlerFactory>().Verify(x => x.Get(It.IsAny <EventType>()), shouldHandleEvent ? Times.Once() : Times.Never());
_mocker.Mock <IEventHandler>().Verify(x => x.HandleAsync(It.IsAny <CallbackEvent>()), shouldHandleEvent ? Times.Once() : Times.Never());
}
public async Task <IActionResult> SendHearingEventAsync(ConferenceEventRequest request)
{
try
{
var conferenceId = Guid.Parse(request.ConferenceId);
var conference = await _conferenceCache.GetOrAddConferenceAsync(conferenceId, () =>
{
_logger.LogTrace("Retrieving conference details for conference: {ConferenceId}", conferenceId);
return(_videoApiClient.GetConferenceDetailsByIdAsync(conferenceId));
});
await UpdateConferenceRoomParticipants(conference, request);
var events = new List <ConferenceEventRequest>()
{
request
};
if (request.IsParticipantAVmr(conference, out var roomId))
{
request.ParticipantRoomId = roomId.ToString();
request.ParticipantId = null;
events = request.CreateEventsForParticipantsInRoom(conference, roomId);
}
var callbackEvents = events.Select(e => TransformAndMapRequest(e, conference)).ToList();
// DO NOT USE Task.WhenAll because the handlers are not thread safe and will overwrite Source<Variable> for each run
foreach (var e in events)
{
await SendEventToVideoApi(e);
}
foreach (var cb in callbackEvents)
{
await PublishEventToUi(cb);
}
return(NoContent());
}
catch (VideoApiException e)
{
_logger.LogError(e, "ConferenceId: {ConferenceId}, ErrorCode: {StatusCode}", request.ConferenceId,
e.StatusCode);
return(StatusCode(e.StatusCode, e.Response));
}
}
public async Task <IActionResult> PostEventAsync(ConferenceEventRequest request)
{
Guid.TryParse(request.ConferenceId, out var conferenceId);
Guid.TryParse(request.ParticipantId, out var participantId);
var command = EventRequestMapper.MapEventRequestToEventCommand(conferenceId, request);
_logger.LogWarning("Handling {ConferenceEventRequest}", nameof(ConferenceEventRequest));
await _commandHandler.Handle(command);
if (request.ShouldSkipEventHandler())
{
_logger.LogDebug("Handling CallbackEvent skipped due to result of ShouldHandleEvent");
return(NoContent());
}
var callbackEvent = EventRequestMapper.MapEventRequestToEventHandlerDto(conferenceId, participantId, request);
await _eventHandlerFactory.Get(callbackEvent.EventType).HandleAsync(callbackEvent);
return(NoContent());
}
public static CallbackEvent MapConferenceEventToCallbackEventModel(ConferenceEventRequest request, Conference conference)
{
var eventType = Enum.Parse <EventType>(request.Event_type.ToString());
var conferenceId = Guid.Parse(request.Conference_id);
Guid.TryParse(request.Participant_id, out var participantId);
var transferFrom = MapRoom(request.Transfer_from.ToString());
var transferTo = MapRoom(request.Transfer_to.ToString());
var callbackEvent = new CallbackEvent
{
EventId = request.Event_id,
EventType = eventType,
ConferenceId = conferenceId,
Reason = request.Reason,
TransferTo = transferTo,
TransferFrom = transferFrom,
TimeStampUtc = request.Time_stamp_utc,
ParticipantId = participantId
};
if (IsEndpointJoined(callbackEvent, conference))
{
callbackEvent.EventType = EventType.EndpointJoined;
}
if (IsEndpointDisconnected(callbackEvent, conference))
{
callbackEvent.EventType = EventType.EndpointDisconnected;
}
if (IsEndpointTransferred(callbackEvent, conference))
{
callbackEvent.EventType = EventType.EndpointTransfer;
}
return(callbackEvent);
}
public static CallbackEvent MapEventRequestToEventHandlerDto(Guid conferenceId, Guid participantId,
ConferenceEventRequest request)
{
GetRoomTypeEnums(request, out var transferTo, out var transferFrom);
var isValidRoomId = long.TryParse(request.ParticipantRoomId, out var roomId);
return(new CallbackEvent
{
EventId = request.EventId,
EventType = request.EventType.MapToDomainEnum(),
ConferenceId = conferenceId,
Reason = request.Reason,
TransferTo = transferTo,
TransferFrom = transferFrom,
TimeStampUtc = request.TimeStampUtc,
ParticipantId = participantId,
Phone = request.Phone,
TransferredFromRoomLabel = request.TransferFrom,
TransferredToRoomLabel = request.TransferTo,
ParticipantRoomId = isValidRoomId ? roomId : (long?)null
});
}
public async Task <IActionResult> SendHearingEventAsync(ConferenceEventRequest request)
{
try
{
_logger.LogTrace("Received callback from Kinly.");
_logger.LogTrace($"ConferenceId: {request.Conference_id}, EventType: {request.Event_type}, Participant ID : {request.Participant_id}");
var conferenceId = Guid.Parse(request.Conference_id);
var conference = await _conferenceCache.GetOrAddConferenceAsync(conferenceId, () =>
{
_logger.LogTrace($"Retrieving conference details for conference: ${conferenceId}");
return(_videoApiClient.GetConferenceDetailsByIdAsync(conferenceId));
});
var callbackEvent = CallbackEventMapper.MapConferenceEventToCallbackEventModel(request, conference);
request.Event_type = Enum.Parse <VAEventType>(callbackEvent.EventType.ToString());
if (callbackEvent.EventType != EventType.VhoCall)
{
_logger.LogTrace($"Raising video event: ConferenceId: {request.Conference_id}, EventType: {request.Event_type}");
await _videoApiClient.RaiseVideoEventAsync(request);
}
if (!string.IsNullOrEmpty(request.Phone))
{
return(NoContent());
}
var handler = _eventHandlerFactory.Get(callbackEvent.EventType);
await handler.HandleAsync(callbackEvent);
return(NoContent());
}
catch (VideoApiException e)
{
_logger.LogError(e, $"ConferenceId: {request.Conference_id}, ErrorCode: {e.StatusCode}");
return(StatusCode(e.StatusCode, e.Response));
}
}
public async Task <IActionResult> PostEventAsync(ConferenceEventRequest request)
{
Guid.TryParse(request.ConferenceId, out var conferenceId);
var command = new SaveEventCommand(conferenceId, request.EventId, request.EventType,
request.TimeStampUtc, request.TransferFrom, request.TransferTo, request.Reason, request.Phone);
if (Guid.TryParse(request.ParticipantId, out var participantId))
{
command.ParticipantId = participantId;
}
_logger.LogWarning("Handling {ConferenceEventRequest}", nameof(ConferenceEventRequest));
await _commandHandler.Handle(command);
if (request.ShouldSkipEventHandler())
{
_logger.LogDebug("Handling CallbackEvent skipped due to result of ShouldHandleEvent.");
return(NoContent());
}
var callbackEvent = new CallbackEvent
{
EventId = request.EventId,
EventType = request.EventType,
ConferenceId = conferenceId,
Reason = request.Reason,
TransferTo = request.TransferTo,
TransferFrom = request.TransferFrom,
TimeStampUtc = request.TimeStampUtc,
ParticipantId = participantId,
Phone = request.Phone
};
await _eventHandlerFactory.Get(request.EventType).HandleAsync(callbackEvent);
return(NoContent());
}
public static List <ConferenceEventRequest> CreateEventsForParticipantsInRoom(
this ConferenceEventRequest request,
Conference conference, long roomId)
{
return(conference.CivilianRooms.First(x => x.Id == roomId).Participants.Select(p =>
{
var json = JsonConvert.SerializeObject(request);
var participantEventRequest = JsonConvert.DeserializeObject <ConferenceEventRequest>(json);
participantEventRequest.ParticipantId = p.ToString();
participantEventRequest.ParticipantRoomId = roomId.ToString();
participantEventRequest.EventType = request.EventType switch
{
EventType.Joined when !participantEventRequest.ParticipantRoomId.IsNullOrEmpty() => EventType
.RoomParticipantJoined,
EventType.Disconnected when !participantEventRequest.ParticipantRoomId.IsNullOrEmpty() => EventType
.RoomParticipantDisconnected,
EventType.Transfer when !participantEventRequest.ParticipantRoomId.IsNullOrEmpty() => EventType
.RoomParticipantTransfer,
_ => participantEventRequest.EventType
};
return participantEventRequest;
}).ToList());
}
public static SaveEventCommand MapEventRequestToEventCommand(Guid conferenceId, ConferenceEventRequest request)
{
GetRoomTypeEnums(request, out var transferTo, out var transferFrom);
var command = new SaveEventCommand(conferenceId, request.EventId, request.EventType.MapToDomainEnum(),
request.TimeStampUtc, transferFrom, transferTo, request.Reason, request.Phone);
if (Guid.TryParse(request.ParticipantId, out var participantId))
{
command.ParticipantId = participantId;
}
command.TransferredFromRoomLabel = request.TransferFrom;
command.TransferredToRoomLabel = request.TransferTo;
if (long.TryParse(request.ParticipantRoomId, out var roomParticipantId))
{
command.ParticipantRoomId = roomParticipantId;
}
return(command);
}
public static bool IsParticipantAndVmrEvent(this ConferenceEventRequest request)
{
return(!request.ParticipantRoomId.IsNullOrEmpty() && !request.ParticipantId.IsNullOrEmpty());
}
public static void Tasks(TaskResponse response, ConferenceEventRequest request)
{
response.Should().BeEquivalentTo(request, options => options.ExcludingMissingMembers());
}
