private Task PublishEventToUi(CallbackEvent callbackEvent)
{
if (callbackEvent == null)
{
return(Task.CompletedTask);
}
var handler = _eventHandlerFactory.Get(callbackEvent.EventType);
return(handler.HandleAsync(callbackEvent));
}
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 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 <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 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());
}
private void Raise(object @event)
{
_eventHandlerFactory.Get(this, @event.GetType())(@event);
}
