public async Task SendJudgeConfirmationEmail(HearingDetailsResponse hearing)
        {
            var hearings = await _bookingsApiClient.GetHearingsByGroupIdAsync(hearing.GroupId.Value);

            AddNotificationRequest request;

            if (hearings.Count == 1)
            {
                var judge = hearing.Participants
                            .First(x => x.UserRoleName.Contains("Judge", StringComparison.CurrentCultureIgnoreCase));
                request = AddNotificationRequestMapper.MapToHearingConfirmationNotification(hearing, judge);
            }
            else
            {
                var firstHearingForGroup = hearings.First();
                if (firstHearingForGroup.Id != hearing.Id)
                {
                    return;
                }
                var judge = firstHearingForGroup.Participants.First(x => x.UserRoleName.Contains("Judge", StringComparison.CurrentCultureIgnoreCase));
                request = AddNotificationRequestMapper.MapToMultiDayHearingConfirmationNotification(firstHearingForGroup, judge, hearings.Count);
            }

            if (request.ContactEmail != null)
            {
                await _notificationApiClient.CreateNewNotificationAsync(request);
            }
        }
 public BookingsHearingResponseBuilder(HearingDetailsResponse hearingResponse)
 {
     _response = new BookingsHearingResponse()
     {
         AudioRecordingRequired = hearingResponse.AudioRecordingRequired,
         CancelReason = hearingResponse.CancelReason,
         CaseTypeName = hearingResponse.CaseTypeName,
         ConfirmedBy = hearingResponse.ConfirmedBy,
         ConfirmedDate = hearingResponse.ConfirmedDate,
         CourtAddress = string.Empty,
         CourtRoom = string.Empty,
         CourtRoomAccount = string.Empty,
         CreatedBy = hearingResponse.CreatedBy,
         CreatedDate = hearingResponse.CreatedDate,
         GroupId = hearingResponse.GroupId,
         HearingId = hearingResponse.Id,
         HearingName = hearingResponse.Cases.Single().Name,
         HearingNumber = hearingResponse.Cases.Single().Number,
         HearingTypeName = hearingResponse.HearingTypeName,
         JudgeName = hearingResponse.Participants.First(x => x.HearingRoleName.Equals("Judge")).DisplayName,
         LastEditBy = hearingResponse.UpdatedBy,
         LastEditDate = hearingResponse.UpdatedDate,
         QuestionnaireNotRequired = hearingResponse.QuestionnaireNotRequired,
         ScheduledDateTime = hearingResponse.ScheduledDateTime,
         ScheduledDuration = hearingResponse.ScheduledDuration,
         Status = hearingResponse.Status
     };
 }
        public async Task ProcessExistingParticipants(Guid hearingId, HearingDetailsResponse hearing,
                                                      EditParticipantRequest participant)
        {
            var existingParticipant = hearing.Participants.FirstOrDefault(p => p.Id.Equals(participant.Id));

            if (existingParticipant != null)
            {
                if (existingParticipant.UserRoleName == "Individual" ||
                    existingParticipant.UserRoleName == "Representative")
                {
                    //Update participant
                    _logger.LogDebug("Updating existing participant {Participant} in hearing {Hearing}",
                                     existingParticipant.Id, hearingId);
                    var updateParticipantRequest = UpdateParticipantRequestMapper.MapTo(participant);
                    await _bookingsApiClient.UpdateParticipantDetailsAsync(hearingId, participant.Id.Value,
                                                                           updateParticipantRequest);
                }
                else if (existingParticipant.UserRoleName == "Judge")
                {
                    //Update Judge
                    _logger.LogDebug("Updating judge {Participant} in hearing {Hearing}",
                                     existingParticipant.Id, hearingId);
                    var updateParticipantRequest = new UpdateParticipantRequest
                    {
                        DisplayName = participant.DisplayName
                    };
                    await _bookingsApiClient.UpdateParticipantDetailsAsync(hearingId, participant.Id.Value,
                                                                           updateParticipantRequest);
                }
            }
        }
Esempio n. 4
0
        public static void HearingDetailsResponse(HearingDetailsResponse response, CreateHearingRequest request)
        {
            response.AudioRecordingRequired.Should().Be(request.AudioRecordingRequired);
            response.CancelReason.Should().BeNull();
            response.CaseTypeName.Should().Be(request.CaseType);
            response.Cases.First().Name.Should().Contain(request.TestType.ToString());
            response.Cases.First().Number.Should().NotBeNullOrWhiteSpace();
            response.Cases.First().IsLeadCase.Should().Be(HearingData.IS_LEAD_CASE);
            response.ConfirmedBy.Should().BeNull();
            response.ConfirmedDate.Should().BeNull();
            VerifyCreatedBy(response, request);
            response.CreatedDate.Should().BeCloseTo(DateTime.UtcNow, TimeSpan.FromSeconds(30));
            response.HearingRoomName.Should().Be(HearingData.HEARING_ROOM_NAME);

            response.HearingTypeName.Should().Be(request.CaseType.Equals(HearingData.CASE_TYPE_NAME)
                ? HearingData.HEARING_TYPE_NAME
                : HearingData.CACD_HEARING_TYPE_NAME);

            response.HearingVenueName.Should().Be(request.Venue);
            response.Id.Should().NotBeEmpty();
            response.OtherInformation.Should().Be(HearingData.OTHER_INFORMATION);
            var expectedCount = UsersIncludeCaseAdminOrVho(request.Users) ? request.Users.Count - 1 : request.Users.Count;

            response.Participants.Count.Should().Be(expectedCount);
            response.QuestionnaireNotRequired.Should().Be(request.QuestionnaireNotRequired);
            response.ScheduledDateTime.Should().Be(request.ScheduledDateTime);
            response.ScheduledDuration.Should().Be(HearingData.SCHEDULED_DURATION);
            response.Status.Should().Be(BookingStatus.Booked);
            response.UpdatedBy.Should().BeNull();
            response.UpdatedDate.Should().BeCloseTo(DateTime.UtcNow, TimeSpan.FromSeconds(30));
            VerifyHearingParticipants(response.Participants, request.Users);
        }
        public async Task SendHearingUpdateEmail(HearingDetailsResponse originalHearing, HearingDetailsResponse updatedHearing, List <ParticipantResponse> participants = null)
        {
            if (updatedHearing.IsGenericHearing())
            {
                return;
            }

            var @case      = updatedHearing.Cases.First();
            var caseName   = @case.Name;
            var caseNumber = @case.Number;

            var participantsToEmail = participants ?? updatedHearing.Participants;

            if (!updatedHearing.DoesJudgeEmailExist() || originalHearing.ConfirmedDate == null || originalHearing.GroupId != originalHearing.Id)
            {
                participantsToEmail = participantsToEmail
                                      .Where(x => !x.UserRoleName.Contains("Judge", StringComparison.CurrentCultureIgnoreCase))
                                      .ToList();
            }

            var requests = participantsToEmail
                           .Select(participant =>
                                   AddNotificationRequestMapper.MapToHearingAmendmentNotification(updatedHearing, participant,
                                                                                                  caseName, caseNumber, originalHearing.ScheduledDateTime, updatedHearing.ScheduledDateTime))
                           .ToList();

            foreach (var request in requests)
            {
                await _notificationApiClient.CreateNewNotificationAsync(request);
            }
        }
        private void AddParticipants(HearingDetailsResponse hearing)
        {
            _response.Participants = new List <ParticipantDetailsResponse>();

            foreach (var participant in hearing.Participants)
            {
                Enum.TryParse(participant.UserRoleName, out UserRole role);
                var response = new ParticipantDetailsResponse()
                {
                    CaseTypeGroup    = participant.UserRoleName,
                    ContactEmail     = participant.ContactEmail,
                    ContactTelephone = participant.Title,
                    CurrentStatus    = ParticipantState.NotSignedIn,
                    DisplayName      = participant.DisplayName,
                    FirstName        = participant.FirstName,
                    HearingRole      = participant.UserRoleName,
                    Id          = participant.Id,
                    LastName    = participant.LastName,
                    Name        = participant.DisplayName,
                    RefId       = participant.Id,
                    Representee = participant.Representee,
                    UserRole    = role,
                    Username    = participant.Username
                };
                _response.Participants.Add(response);
            }
        }
Esempio n. 7
0
 public void Setup()
 {
     _hearing = new HearingDetailsResponse
     {
         Id = Guid.NewGuid()
     };
 }
        private void SubmitAnswers(IEnumerable <SuitabilityAnswersRequest> answers, HearingDetailsResponse hearing)
        {
            var participantId = hearing.Participants.First(x => x.LastName.ToLower().Equals(_c.CurrentUser.LastName.ToLower())).Id;
            var response      = _c.Api.SetSuitabilityAnswers(hearing.Id, participantId, answers);

            response.StatusCode.Should().Be(HttpStatusCode.NoContent);
        }
 private async Task SendJudgeEmailIfNeeded(HearingDetailsResponse updatedHearing, HearingDetailsResponse originalHearing)
 {
     if (updatedHearing.HasJudgeEmailChanged(originalHearing) &&
         updatedHearing.Status == BookingStatus.Created)
     {
         await _hearingsService.SendJudgeConfirmationEmail(updatedHearing);
     }
 }
Esempio n. 10
0
 private static void VerifyCreatedBy(HearingDetailsResponse response, CreateHearingRequest request)
 {
     response.CreatedBy.Should().Be(
         UsersIncludeCaseAdminOrVho(request.Users)
             ? request.Users.First(x =>
                                   x.UserType == UserType.CaseAdmin || x.UserType == UserType.VideoHearingsOfficer).Username
             : UserData.DEFAULT_CREATED_BY_USER);
 }
Esempio n. 11
0
 public static bool HasJudgeEmailChanged(this HearingDetailsResponse hearing, HearingDetailsResponse anotherHearing)
 {
     if (string.IsNullOrWhiteSpace(anotherHearing.OtherInformation) && string.IsNullOrWhiteSpace(hearing.OtherInformation))
     {
         return(false);
     }
     return(hearing.GetJudgeEmail() != anotherHearing.GetJudgeEmail());
 }
        public static HearingDetailsResponse WithEndPoints(this HearingDetailsResponse hearingDetailsResponse, int size)
        {
            var endPoints = Builder <EndpointResponse> .CreateListOfSize(size).Build().ToList();

            hearingDetailsResponse.Endpoints = endPoints;

            return(hearingDetailsResponse);
        }
 private async Task RemoveEndpointsFromHearing(HearingDetailsResponse hearing, IEnumerable <EndpointResponse> listOfEndpointsToDelete)
 {
     foreach (var endpointToDelete in listOfEndpointsToDelete)
     {
         _logger.LogDebug("Removing endpoint {Endpoint} - {EndpointDisplayName} from hearing {Hearing}",
                          endpointToDelete.Id, endpointToDelete.DisplayName, hearing.Id);
         await _bookingsApiClient.RemoveEndPointFromHearingAsync(hearing.Id, endpointToDelete.Id);
     }
 }
Esempio n. 14
0
 private static void AssertDetails(HearingDetailsResponse hearing, Test testData)
 {
     hearing.Cases.First().Name.Should().Contain(testData.HearingDetails.CaseName);
     hearing.Cases.First().Number.Should().Contain(testData.HearingDetails.CaseNumber);
     hearing.CaseTypeName.Should().Be(testData.HearingDetails.CaseType.Name);
     hearing.HearingRoomName.Should().Be(testData.HearingSchedule.Room);
     hearing.HearingTypeName.Should().Be(testData.HearingDetails.HearingType.Name);
     hearing.HearingVenueName.Should().Be(testData.HearingSchedule.HearingVenue);
     OtherInformationSteps.GetOtherInfo(hearing.OtherInformation).Should().Be(OtherInformationSteps.GetOtherInfo(testData.TestData.OtherInformationDetails.OtherInformation));
 }
Esempio n. 15
0
        public static string GetJudgePhone(this HearingDetailsResponse hearing)
        {
            var phone = GetOtherInformationObject(hearing.OtherInformation).JudgePhone;

            if (phone == string.Empty)
            {
                return(null);
            }
            return(phone);
        }
Esempio n. 16
0
        public static string GetJudgeEmail(this HearingDetailsResponse hearing)
        {
            var email = GetOtherInformationObject(hearing.OtherInformation)?.JudgeEmail;

            if (email == string.Empty)
            {
                return(null);
            }
            return(email);
        }
        private string GetJudgeEmail(HearingDetailsResponse hearing)
        {
            var email = GetOtherInformationObject(hearing.OtherInformation).JudgeEmail;

            if (email == string.Empty)
            {
                return(null);
            }
            return(email);
        }
Esempio n. 18
0
 private static void AssertQuestionnaire(HearingDetailsResponse hearing, Test testData)
 {
     if (!hearing.Cases.First().Name.Contains("Day") || hearing.Cases.First().Name.Contains("Day 1 of"))
     {
         hearing.QuestionnaireNotRequired.Should().BeFalse();
     }
     else
     {
         hearing.QuestionnaireNotRequired.Should().BeTrue();
     }
 }
        public static AddNotificationRequest MapToMultiDayHearingConfirmationNotification(
            HearingDetailsResponse hearing,
            ParticipantResponse participant, int days)
        {
            var @case           = hearing.Cases.First();
            var cleanedCaseName = @case.Name.Replace($"Day 1 of {days}", string.Empty).Trim();
            var parameters      = new Dictionary <string, string>
            {
                { "case name", cleanedCaseName },
                { "case number", @case.Number },
                { "time", hearing.ScheduledDateTime.ToEmailTimeGbLocale() },
                { "Start Day Month Year", hearing.ScheduledDateTime.ToEmailDateGbLocale() },
                { "number of days", days.ToString() }
            };
            NotificationType notificationType;

            if (participant.UserRoleName.Contains("Judge", StringComparison.InvariantCultureIgnoreCase))
            {
                notificationType = NotificationType.HearingConfirmationJudgeMultiDay;
                parameters.Add("judge", participant.DisplayName);
                parameters.Add("courtroom account username", participant.Username);
                participant.ContactEmail    = hearing.GetJudgeEmail();
                participant.TelephoneNumber = hearing.GetJudgePhone();
            }
            else if (participant.UserRoleName.Contains("Judicial Office Holder",
                                                       StringComparison.InvariantCultureIgnoreCase))
            {
                notificationType = NotificationType.HearingConfirmationJohMultiDay;
                parameters.Add("judicial office holder", $"{participant.FirstName} {participant.LastName}");
            }
            else if (participant.UserRoleName.Contains("Representative", StringComparison.InvariantCultureIgnoreCase))
            {
                notificationType = NotificationType.HearingConfirmationRepresentativeMultiDay;
                parameters.Add("client name", participant.Representee);
                parameters.Add("solicitor name", $"{participant.FirstName} {participant.LastName}");
            }
            else
            {
                notificationType = NotificationType.HearingConfirmationLipMultiDay;
                parameters.Add("name", $"{participant.FirstName} {participant.LastName}");
            }

            return(new AddNotificationRequest
            {
                HearingId = hearing.Id,
                MessageType = MessageType.Email,
                ContactEmail = participant.ContactEmail,
                NotificationType = notificationType,
                ParticipantId = participant.Id,
                PhoneNumber = participant.TelephoneNumber,
                Parameters = parameters
            });
        }
        public static AddNotificationRequest MapToHearingAmendmentNotification(HearingDetailsResponse hearing,
                                                                               ParticipantResponse participant, string caseName, string caseNumber, DateTime originalDateTime,
                                                                               DateTime newDateTime)
        {
            var parameters = new Dictionary <string, string>
            {
                { "case name", caseName },
                { "case number", caseNumber },
                { "Old time", originalDateTime.ToEmailTimeGbLocale() },
                { "New time", newDateTime.ToEmailTimeGbLocale() },
                { "Old Day Month Year", originalDateTime.ToEmailDateGbLocale() },
                { "New Day Month Year", newDateTime.ToEmailDateGbLocale() }
            };

            NotificationType notificationType;

            if (participant.UserRoleName.Contains("Judge", StringComparison.InvariantCultureIgnoreCase))
            {
                notificationType = NotificationType.HearingAmendmentJudge;
                parameters.Add("judge", participant.DisplayName);
                parameters.Add("courtroom account username", participant.Username);
                participant.ContactEmail    = hearing.GetJudgeEmail();
                participant.TelephoneNumber = hearing.GetJudgePhone();
            }
            else if (participant.UserRoleName.Contains("Judicial Office Holder",
                                                       StringComparison.InvariantCultureIgnoreCase))
            {
                notificationType = NotificationType.HearingAmendmentJoh;
                parameters.Add("judicial office holder", $"{participant.FirstName} {participant.LastName}");
            }
            else if (participant.UserRoleName.Contains("Representative", StringComparison.InvariantCultureIgnoreCase))
            {
                notificationType = NotificationType.HearingAmendmentRepresentative;
                parameters.Add("client name", participant.Representee);
                parameters.Add("solicitor name", $"{participant.FirstName} {participant.LastName}");
            }
            else
            {
                notificationType = NotificationType.HearingAmendmentLip;
                parameters.Add("name", $"{participant.FirstName} {participant.LastName}");
            }

            return(new AddNotificationRequest
            {
                HearingId = hearing.Id,
                MessageType = MessageType.Email,
                ContactEmail = participant.ContactEmail,
                NotificationType = notificationType,
                ParticipantId = participant.Id,
                PhoneNumber = participant.TelephoneNumber,
                Parameters = parameters
            });
        }
Esempio n. 21
0
 public static bool DoesJudgePhoneExist(this HearingDetailsResponse hearing)
 {
     if (hearing.OtherInformation != null)
     {
         var otherInformationDetails = GetOtherInformationObject(hearing.OtherInformation);
         if (otherInformationDetails.JudgePhone != null)
         {
             return(true);
         }
     }
     return(false);
 }
Esempio n. 22
0
        private async Task ConfirmMultiDayHearing(HearingDetailsResponse hearing)
        {
            var confirmRequest = new UpdateBookingStatusRequestBuilder()
                                 .UpdatedBy(HearingData.CREATED_BY(Context.Config.UsernameStem))
                                 .Build();

            await BookingApiClient.UpdateBookingStatusAsync(hearing.Id, confirmRequest);

            Conference = await GetConferenceByHearingIdPollingAsync(hearing.Id);

            Verify.ConferenceDetailsResponse(Conference, hearing);
        }
 private async Task AddEndpointToHearing(Guid hearingId, HearingDetailsResponse hearing,
                                         EditEndpointRequest endpoint)
 {
     _logger.LogDebug("Adding endpoint {EndpointDisplayName} to hearing {Hearing}",
                      endpoint.DisplayName, hearingId);
     var addEndpointRequest = new AddEndpointRequest
     {
         DisplayName             = endpoint.DisplayName,
         DefenceAdvocateUsername = endpoint.DefenceAdvocateUsername
     };
     await _bookingsApiClient.AddEndPointToHearingAsync(hearing.Id, addEndpointRequest);
 }
        private static Dictionary <string, string> InitConfirmReminderParams(HearingDetailsResponse hearing)
        {
            var @case = hearing.Cases.First();

            return(new Dictionary <string, string>
            {
                { "case name", @case.Name },
                { "case number", @case.Number },
                { "time", hearing.ScheduledDateTime.ToEmailTimeGbLocale() },
                { "day month year", hearing.ScheduledDateTime.ToEmailDateGbLocale() }
            });
        }
        private async Task RemoveParticipantsFromHearing(Guid hearingId, EditHearingRequest request,
                                                         HearingDetailsResponse originalHearing)
        {
            var deleteParticipantList =
                originalHearing.Participants.Where(p => request.Participants.All(rp => rp.Id != p.Id));

            foreach (var participantToDelete in deleteParticipantList)
            {
                _logger.LogDebug("Removing existing participant {Participant} from hearing {Hearing}",
                                 participantToDelete.Id, hearingId);
                await _bookingsApiClient.RemoveParticipantFromHearingAsync(hearingId, participantToDelete.Id);
            }
        }
Esempio n. 26
0
        private static Hearing Map(HearingDetailsResponse response)
        {
            var hearingCase = response.Cases.FirstOrDefault(c => c.Is_lead_case.Value) ?? response.Cases.First();

            return(new Hearing(
                       response.Id.Value,
                       hearingCase.Name,
                       hearingCase.Number,
                       response.Scheduled_date_time.Value,
                       response.Case_type_name,
                       response.Hearing_type_name
                       ));
        }
Esempio n. 27
0
        public void MatchesHearing(HearingDetailsResponse hearing)
        {
            var hearingCase = hearing.Cases.First();

            _conference.Case_name.Should().Be(hearingCase.Name);
            _conference.Case_number.Should().Be(hearingCase.Number);
            _conference.Case_type.Should().Be(hearing.Case_type_name);
            _conference.Current_status.Should().Be(ConferenceState.NotStarted);
            _conference.Hearing_id.Should().Be(hearing.Id);
            _conference.Scheduled_date_time.Should().Be(hearing.Scheduled_date_time);
            _conference.Scheduled_duration.Should().Be(hearing.Scheduled_duration);
            ParticipantsMatch(hearing.Participants);
        }
Esempio n. 28
0
        private static Hearing Map(HearingDetailsResponse response)
        {
            var hearingCase = response.Cases.FirstOrDefault(c => c.IsLeadCase) ?? response.Cases.First();

            return(new Hearing(
                       response.Id,
                       hearingCase.Name,
                       hearingCase.Number,
                       response.ScheduledDateTime,
                       response.CaseTypeName,
                       response.HearingTypeName
                       ));
        }
        private async Task SendEmailsToParticipantsAddedToHearing(List <ParticipantRequest> newParticipantList,
                                                                  HearingDetailsResponse updatedHearing, Dictionary <string, User> usernameAdIdDict, IEnumerable <string> newParticipantEmails)
        {
            if (newParticipantList.Any())
            {
                _logger.LogInformation("Sending email notification to the participants");
                await _hearingsService.SendNewUserEmailParticipants(updatedHearing, usernameAdIdDict);

                var participantsForConfirmation = updatedHearing.Participants
                                                  .Where(p => newParticipantEmails.Contains(p.ContactEmail)).ToList();
                await _hearingsService.SendHearingConfirmationEmail(updatedHearing, participantsForConfirmation);

                _logger.LogInformation("Successfully sent emails to participants - {Hearing}", updatedHearing.Id);
            }
        }
        public static HearingDetailsResponse WithParticipant(this HearingDetailsResponse hearingDetailsResponse, string userRoleName, string userName = null)
        {
            var participant = Builder <ParticipantResponse> .CreateNew()
                              .With(x => x.Id           = Guid.NewGuid())
                              .With(x => x.UserRoleName = userRoleName);

            if (!string.IsNullOrEmpty(userName))
            {
                participant.With(x => x.Username = userName);
            }

            hearingDetailsResponse.Participants.Add(participant.Build());

            return(hearingDetailsResponse);
        }