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 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 Should_return_badrequest_with_an_invalid_hearingid()
{
var request = new UpdateHearingRequest();
var hearingId = Guid.Empty;
var result = await Controller.UpdateHearingDetails(hearingId, request);
result.Should().NotBeNull();
var objectResult = (BadRequestObjectResult)result;
objectResult.StatusCode.Should().Be((int)HttpStatusCode.BadRequest);
((SerializableError)objectResult.Value).ContainsKeyAndErrorMessage(nameof(hearingId), $"Please provide a valid {nameof(hearingId)}");
}
public async Task Should_update_hearing_with_status_created_and_send_event_to_video()
{
var request = new UpdateHearingRequest
{
ScheduledDateTime = DateTime.Now.AddDays(2),
HearingRoomName = "123",
ScheduledDuration = 15,
OtherInformation = "note",
HearingVenueName = "venue1",
Cases = new List <CaseRequest> {
new CaseRequest {
Name = "123XX", Number = "123YY", IsLeadCase = true
}
},
UpdatedBy = "*****@*****.**"
};
var hearingId = Guid.NewGuid();
var hearing = GetHearing("123");
hearing.UpdateStatus(BookingStatus.Created, "administrator", string.Empty);
hearing.UpdateHearingDetails(new HearingVenue(1, "venue1"), DateTime.Now.AddDays(2),
15, "123", "note", "administrator", new List <Case> {
new Case("123", "name")
}, true, true);
QueryHandlerMock
.Setup(x => x.Handle <GetHearingByIdQuery, VideoHearing>(It.IsAny <GetHearingByIdQuery>()))
.ReturnsAsync(hearing);
var venues = new List <HearingVenue> {
new HearingVenue(1, "venue1"),
};
QueryHandlerMock
.Setup(x => x.Handle <GetHearingVenuesQuery, List <HearingVenue> >(It.IsAny <GetHearingVenuesQuery>()))
.ReturnsAsync(venues);
var result = await Controller.UpdateHearingDetails(hearingId, request);
result.Should().NotBeNull();
var objectResult = (OkObjectResult)result;
objectResult.StatusCode.Should().Be((int)HttpStatusCode.OK);
var message = SbQueueClient.ReadMessageFromQueue();
var typedMessage = (HearingDetailsUpdatedIntegrationEvent)message.IntegrationEvent;
typedMessage.Should().NotBeNull();
typedMessage.Hearing.CaseName.Should().Be("name");
}
public async Task Should_return_notfound_when_no_matching_venue_found()
{
var request = new UpdateHearingRequest
{
ScheduledDateTime = DateTime.Now.AddDays(2),
HearingRoomName = "123",
ScheduledDuration = 15,
OtherInformation = "note",
HearingVenueName = "venue2",
Cases = new List <CaseRequest> {
new CaseRequest {
Name = "123XX", Number = "123YY", IsLeadCase = true
}
},
UpdatedBy = "*****@*****.**"
};
var hearingId = Guid.NewGuid();
var hearing = GetHearing("123");
hearing.UpdateStatus(BookingStatus.Created, "administrator", string.Empty);
hearing.UpdateHearingDetails(new HearingVenue(1, "venue1"), DateTime.Now.AddDays(2),
15, "123", "note", "administrator", new List <Case> {
new Case("123", "name")
}, true, true);
QueryHandlerMock
.Setup(x => x.Handle <GetHearingByIdQuery, VideoHearing>(It.IsAny <GetHearingByIdQuery>()))
.ReturnsAsync(hearing);
var venues = new List <HearingVenue> {
new HearingVenue(1, "venue1"),
};
QueryHandlerMock
.Setup(x => x.Handle <GetHearingVenuesQuery, List <HearingVenue> >(It.IsAny <GetHearingVenuesQuery>()))
.ReturnsAsync(venues);
var result = await Controller.UpdateHearingDetails(hearingId, request);
result.Should().NotBeNull();
var objectResult = (BadRequestObjectResult)result;
objectResult.StatusCode.Should().Be((int)HttpStatusCode.BadRequest);
((SerializableError)objectResult.Value).ContainsKeyAndErrorMessage(nameof(request.HearingVenueName),
"Hearing venue does not exist");
}
public static UpdateHearingRequest MapTo(EditHearingRequest editHearingRequest, string userName)
{
var updateHearingRequest = new UpdateHearingRequest
{
HearingRoomName = editHearingRequest.HearingRoomName,
HearingVenueName = editHearingRequest.HearingVenueName,
OtherInformation = editHearingRequest.OtherInformation,
ScheduledDateTime = editHearingRequest.ScheduledDateTime,
ScheduledDuration = editHearingRequest.ScheduledDuration,
UpdatedBy = userName,
Cases = new List <CaseRequest>
{
new CaseRequest
{
Name = editHearingRequest.Case.Name,
Number = editHearingRequest.Case.Number
}
},
QuestionnaireNotRequired = false,
AudioRecordingRequired = editHearingRequest.AudioRecordingRequired
};
return(updateHearingRequest);
}
public async Task Should_update_conference_when_hearing_updated()
{
await CreateAndConfirmHearing();
var caseRequests = new List <CaseRequest>
{
new CaseRequest
{
IsLeadCase = Hearing.Cases.First().IsLeadCase,
Name = $"{Hearing.Cases.First().Name} {HearingData.UPDATED_TEXT}",
Number = $"{Hearing.Cases.First().Number} {HearingData.UPDATED_TEXT}"
}
};
var request = new UpdateHearingRequest
{
AudioRecordingRequired = !Hearing.AudioRecordingRequired,
Cases = caseRequests,
HearingRoomName = $"{Hearing.HearingRoomName} {HearingData.UPDATED_TEXT}",
HearingVenueName = Hearing.HearingVenueName.Equals(HearingData.VENUE_NAME) ? HearingData.VENUE_NAME_ALTERNATIVE : HearingData.VENUE_NAME,
OtherInformation = $"{Hearing.OtherInformation} {HearingData.UPDATED_TEXT}",
QuestionnaireNotRequired = !Hearing.QuestionnaireNotRequired,
ScheduledDateTime = Hearing.ScheduledDateTime.AddMinutes(10),
ScheduledDuration = Hearing.ScheduledDuration / 2,
UpdatedBy = EmailData.NON_EXISTENT_USERNAME
};
var hearingDetails = await BookingApiClient.UpdateHearingDetailsAsync(Hearing.Id, request);
Verify.UpdatedHearing(hearingDetails, request);
var response = await GetUpdatedConferenceDetailsPollingAsync(Hearing.Id);
response.Should().NotBeNull();
Verify.UpdatedConference(response, request);
}
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 static void UpdatedHearing(HearingDetailsResponse hearingDetails, UpdateHearingRequest request)
{
hearingDetails.Should().BeEquivalentTo(request);
}
