public async Task <IActionResult> UpdateHearingDetails(Guid hearingId, [FromBody] UpdateHearingRequest request)
{
if (hearingId == Guid.Empty)
{
ModelState.AddModelError(nameof(hearingId), $"Please provide a valid {nameof(hearingId)}");
return(BadRequest(ModelState));
}
var result = new UpdateHearingRequestValidation().Validate(request);
if (!result.IsValid)
{
ModelState.AddFluentValidationErrors(result.Errors);
return(BadRequest(ModelState));
}
var getHearingByIdQuery = new GetHearingByIdQuery(hearingId);
var videoHearing = await _queryHandler.Handle <GetHearingByIdQuery, VideoHearing>(getHearingByIdQuery);
if (videoHearing == null)
{
return(NotFound());
}
var venue = await GetVenue(request.HearingVenueName);
if (venue == null)
{
ModelState.AddModelError(nameof(request.HearingVenueName), "Hearing venue does not exist");
return(BadRequest(ModelState));
}
var cases = MapCase(request.Cases);
// use existing video hearing values here when request properties are null
request.AudioRecordingRequired ??= videoHearing.AudioRecordingRequired;
request.QuestionnaireNotRequired ??= videoHearing.QuestionnaireNotRequired;
request.HearingRoomName ??= videoHearing.HearingRoomName;
request.OtherInformation ??= videoHearing.OtherInformation;
var command = new UpdateHearingCommand(hearingId, request.ScheduledDateTime,
request.ScheduledDuration, venue, request.HearingRoomName, request.OtherInformation,
request.UpdatedBy, cases, request.QuestionnaireNotRequired.Value, request.AudioRecordingRequired.Value);
await _commandHandler.Handle(command);
var hearingMapper = new HearingToDetailsResponseMapper();
var updatedHearing = await _queryHandler.Handle <GetHearingByIdQuery, VideoHearing>(getHearingByIdQuery);
var response = hearingMapper.MapHearingToDetailedResponse(updatedHearing);
if (videoHearing.Status == BookingStatus.Created)
{
// publish this event when Hearing is set for ready for video
await _eventPublisher.PublishAsync(new HearingDetailsUpdatedIntegrationEvent(updatedHearing));
}
return(Ok(response));
}
public async Task <IActionResult> GetHearingsByGroupId(Guid groupId)
{
var query = new GetHearingsByGroupIdQuery(groupId);
var hearings = await _queryHandler.Handle <GetHearingsByGroupIdQuery, List <VideoHearing> >(query);
var hearingMapper = new HearingToDetailsResponseMapper();
var response = hearings.Select(hearingMapper.MapHearingToDetailedResponse).ToList();
return(Ok(response));
}
public async Task <IActionResult> GetHearingsByUsername([FromQuery] string username)
{
var query = new GetHearingsByUsernameQuery(username);
var hearings = await _queryHandler.Handle <GetHearingsByUsernameQuery, List <VideoHearing> >(query);
var hearingMapper = new HearingToDetailsResponseMapper();
var response = hearings.Select(hearingMapper.MapHearingToDetailedResponse).ToList();
return(Ok(response));
}
public async Task should_send_message_to_bqs_with_updated_hearing()
{
var videoHearing = GetHearing("Original Hearing");
videoHearing.UpdateStatus(BookingStatus.Created, "initial", null);
var request = new UpdateHearingRequest
{
OtherInformation = videoHearing.OtherInformation + " Updated",
ScheduledDuration = 999,
UpdatedBy = "updated by test",
ScheduledDateTime = DateTime.Today.AddDays(2),
HearingRoomName = "Updated room name",
HearingVenueName = "Updated venue name",
QuestionnaireNotRequired = false,
AudioRecordingRequired = true,
Cases = null
};
var hearingVenueOriginal = videoHearing.HearingVenue;
var newVenue = new HearingVenue(111, request.HearingVenueName);
var updatedHearing = GetHearing("Case Update Test");
updatedHearing.SetProtected(nameof(updatedHearing.Id), videoHearing.Id);
updatedHearing.UpdateHearingDetails(newVenue,
request.ScheduledDateTime, request.ScheduledDuration, request.HearingRoomName, request.OtherInformation,
request.UpdatedBy, new List <Case>(), request.QuestionnaireNotRequired.Value,
request.AudioRecordingRequired.Value);
QueryHandlerMock
.SetupSequence(x => x.Handle <GetHearingByIdQuery, VideoHearing>(It.IsAny <GetHearingByIdQuery>()))
.ReturnsAsync(videoHearing).ReturnsAsync(updatedHearing);
QueryHandlerMock
.Setup(x => x.Handle <GetHearingVenuesQuery, List <HearingVenue> >(It.IsAny <GetHearingVenuesQuery>()))
.ReturnsAsync(new List <HearingVenue> {
hearingVenueOriginal, newVenue
});
var expectedResult = new HearingToDetailsResponseMapper().MapHearingToDetailedResponse(updatedHearing);
var result = await Controller.UpdateHearingDetails(videoHearing.Id, request);
var ob = result.As <OkObjectResult>();
ob.Should().NotBeNull();
ob.Value.As <HearingDetailsResponse>().Should().BeEquivalentTo(expectedResult);
var message = SbQueueClient.ReadMessageFromQueue();
var payload = message.IntegrationEvent.As <HearingDetailsUpdatedIntegrationEvent>();
payload.Hearing.HearingId.Should().Be(updatedHearing.Id);
payload.Hearing.GroupId.Should().Be(updatedHearing.SourceId.GetValueOrDefault());
payload.Hearing.RecordAudio.Should().Be(request.AudioRecordingRequired.Value);
payload.Hearing.ScheduledDuration.Should().Be(request.ScheduledDuration);
payload.Hearing.ScheduledDateTime.Should().Be(request.ScheduledDateTime);
payload.Hearing.HearingVenueName.Should().Be(request.HearingVenueName);
}
public async Task <IActionResult> GetHearingDetailsById(Guid hearingId)
{
if (hearingId == Guid.Empty)
{
ModelState.AddModelError(nameof(hearingId), $"Please provide a valid {nameof(hearingId)}");
return(BadRequest(ModelState));
}
var query = new GetHearingByIdQuery(hearingId);
var videoHearing = await _queryHandler.Handle <GetHearingByIdQuery, VideoHearing>(query);
if (videoHearing == null)
{
return(NotFound());
}
var hearingMapper = new HearingToDetailsResponseMapper();
var response = hearingMapper.MapHearingToDetailedResponse(videoHearing);
return(Ok(response));
}
public async Task <IActionResult> BookNewHearing(BookNewHearingRequest request)
{
try
{
if (request == null)
{
const string modelErrorMessage = "BookNewHearingRequest is null";
const string logModelErrorMessage = "BookNewHearing Error: BookNewHearingRequest is null";
return(ModelStateErrorLogger(nameof(BookNewHearingRequest), modelErrorMessage, logModelErrorMessage,
null, SeverityLevel.Information));
}
var result = await new BookNewHearingRequestValidation().ValidateAsync(request);
if (!result.IsValid)
{
const string logBookNewHearingValidationError = "BookNewHearing Validation Errors";
const string emptyPayLoadErrorMessage = "Empty Payload";
const string keyPayload = "payload";
ModelState.AddFluentValidationErrors(result.Errors);
var dictionary = result.Errors.ToDictionary(x => x.PropertyName + "-" + Guid.NewGuid(), x => x.ErrorMessage);
var payload = JsonConvert.SerializeObject(request);
dictionary.Add(keyPayload, !string.IsNullOrWhiteSpace(payload) ? payload : emptyPayLoadErrorMessage);
_logger.TrackTrace(logBookNewHearingValidationError, SeverityLevel.Error, dictionary);
return(BadRequest(ModelState));
}
var query = new GetCaseTypeQuery(request.CaseTypeName);
var caseType = await _queryHandler.Handle <GetCaseTypeQuery, CaseType>(query);
if (caseType == null)
{
const string logCaseDoesNotExist = "BookNewHearing Error: Case type does not exist";
return(ModelStateErrorLogger(nameof(request.CaseTypeName),
"Case type does not exist", logCaseDoesNotExist, request.CaseTypeName, SeverityLevel.Error));
}
var hearingType = caseType.HearingTypes.SingleOrDefault(x => x.Name == request.HearingTypeName);
if (hearingType == null)
{
const string logHearingTypeDoesNotExist = "BookNewHearing Error: Hearing type does not exist";
return(ModelStateErrorLogger(nameof(request.HearingTypeName),
"Hearing type does not exist", logHearingTypeDoesNotExist, request.HearingTypeName, SeverityLevel.Error));
}
var venue = await GetVenue(request.HearingVenueName);
if (venue == null)
{
const string logHearingVenueDoesNotExist = "BookNewHearing Error: Hearing venue does not exist";
return(ModelStateErrorLogger(nameof(request.HearingVenueName),
"Hearing venue does not exist", logHearingVenueDoesNotExist, request.HearingVenueName, SeverityLevel.Error));
}
var cases = request.Cases.Select(x => new Case(x.Number, x.Name)).ToList();
const string logHasCases = "BookNewHearing got cases";
const string keyCases = "Cases";
_logger.TrackTrace(logHasCases, SeverityLevel.Information, new Dictionary <string, string>
{
{ keyCases, string.Join(", ", cases.Select(x => new { x.Name, x.Number })) }
});
var createVideoHearingCommand = BookNewHearingRequestToCreateVideoHearingCommandMapper.Map(
request, caseType, hearingType, venue, cases, _randomGenerator, _kinlyConfiguration.SipAddressStem);
const string logCallingDb = "BookNewHearing Calling DB...";
const string dbCommand = "createVideoHearingCommand";
const string logSaveSuccess = "BookNewHearing DB Save Success";
const string logNewHearingId = "NewHearingId";
_logger.TrackTrace(logCallingDb, SeverityLevel.Information, new Dictionary <string, string> {
{ dbCommand, JsonConvert.SerializeObject(createVideoHearingCommand) }
});
await _commandHandler.Handle(createVideoHearingCommand);
_logger.TrackTrace(logSaveSuccess, SeverityLevel.Information, new Dictionary <string, string> {
{ logNewHearingId, createVideoHearingCommand.NewHearingId.ToString() }
});
var videoHearingId = createVideoHearingCommand.NewHearingId;
var getHearingByIdQuery = new GetHearingByIdQuery(videoHearingId);
var queriedVideoHearing = await _queryHandler.Handle <GetHearingByIdQuery, VideoHearing>(getHearingByIdQuery);
const string logRetrieveNewHearing = "BookNewHearing Retrieved new hearing from DB";
const string keyHearingId = "HearingId";
const string keyCaseType = "CaseType";
const string keyParticipantCount = "Participants.Count";
_logger.TrackTrace(logRetrieveNewHearing, SeverityLevel.Information, new Dictionary <string, string>
{
{ keyHearingId, queriedVideoHearing.Id.ToString() },
{ keyCaseType, queriedVideoHearing.CaseType?.Name },
{ keyParticipantCount, queriedVideoHearing.Participants.Count.ToString() },
});
var hearingMapper = new HearingToDetailsResponseMapper();
var response = hearingMapper.MapHearingToDetailedResponse(queriedVideoHearing);
const string logProcessFinished = "BookNewHearing Finished, returning response";
_logger.TrackTrace(logProcessFinished, SeverityLevel.Information, new Dictionary <string, string> {
{ "response", JsonConvert.SerializeObject(response) }
});
return(CreatedAtAction(nameof(GetHearingDetailsById), new { hearingId = response.Id }, response));
}
catch (Exception ex)
{
const string keyPayload = "payload";
const string keyScheduledDateTime = "ScheduledDateTime";
const string keyScheduledDuration = "ScheduledDuration";
const string keyCaseTypeName = "CaseTypeName";
const string keyHearingTypeName = "HearingTypeName";
if (request != null)
{
var payload = JsonConvert.SerializeObject(request);
_logger.TrackError(ex, new Dictionary <string, string>
{
{ keyPayload, !string.IsNullOrWhiteSpace(payload) ? payload : "Empty Payload" },
{ keyScheduledDateTime, request.ScheduledDateTime.ToString("s") },
{ keyScheduledDuration, request.ScheduledDuration.ToString() },
{ keyCaseTypeName, request.CaseTypeName },
{ keyHearingTypeName, request.HearingTypeName }
});
}
throw;
}
}
