Beispiel #1
0
        public async Task Should_Update_Participant_With_Links()
        {
            var editPrefix    = " _Edit";
            var seededHearing = await Hooks.SeedVideoHearing();

            TestContext.WriteLine($"New seeded video hearing id: {seededHearing.Id}");

            var individuals = seededHearing.GetParticipants()
                              .Where(x => x.HearingRole.UserRole.Name.Equals("Individual")).ToList();
            var interpretee = individuals[0];
            var interpreter = individuals[1];

            var link = new LinkedParticipantDto(
                interpreter.Person.ContactEmail,
                interpretee.Person.ContactEmail,
                LinkedParticipantType.Interpreter);

            var title           = interpreter.Person.Title + editPrefix;
            var displayName     = interpreter.DisplayName + editPrefix;
            var telephoneNumber = "11112222333";

            var links = new List <LinkedParticipantDto> {
                link
            };
            var updateParticipantCommand = new UpdateParticipantCommand(seededHearing.Id, interpreter.Id,
                                                                        title, displayName, telephoneNumber, null, null, links);
            await _commandHandler.Handle(updateParticipantCommand);

            var updatedRepresentative = updateParticipantCommand.UpdatedParticipant;

            updatedRepresentative.Should().NotBeNull();
            updatedRepresentative.LinkedParticipants.Should().NotBeNull();
            updatedRepresentative.GetLinkedParticipants().Should().NotBeEmpty();
        }
Beispiel #2
0
        private static List <LinkedParticipantDto> GetLinkedParticipantDtos(Hearing hearing)
        {
            var hearingParticipants = hearing.Participants.Where(x => x.LinkedParticipants.Any()).ToList();

            var linkedParticipantDtos = new List <LinkedParticipantDto>();

            foreach (var hearingParticipant in hearingParticipants)
            {
                var participantEmail = hearingParticipant.Person.ContactEmail;
                var participantLink  = hearingParticipant.GetLinkedParticipants()
                                       .FirstOrDefault(x => x.ParticipantId == hearingParticipant.Id);
                if (participantLink != null)
                {
                    var linkedParticipant = hearing.Participants.SingleOrDefault(x => x.Id == participantLink.LinkedId);

                    var linkedParticipantDto = new LinkedParticipantDto
                                               (
                        participantEmail,
                        linkedParticipant?.Person.ContactEmail,
                        participantLink.Type
                                               );

                    linkedParticipantDtos.Add(linkedParticipantDto);
                }
            }

            return(linkedParticipantDtos);
        }
        public async Task Should_Add_Participant_With_A_Link()
        {
            var seededHearing = await Hooks.SeedVideoHearing();

            TestContext.WriteLine($"New seeded video hearing id: {seededHearing.Id}");
            _newHearingId = seededHearing.Id;

            const string caseTypeName = "Generic";
            var          caseType     = GetCaseTypeFromDb(caseTypeName);

            var applicantCaseRole = caseType.CaseRoles.First(x => x.Name == "Applicant");
            var applicantRepresentativeHearingRole =
                applicantCaseRole.HearingRoles.First(x => x.Name == "Representative");

            var respondentCaseRole = caseType.CaseRoles.First(x => x.Name == "Respondent");
            var respondentRepresentativeHearingRole =
                respondentCaseRole.HearingRoles.First(x => x.Name == "Representative");

            var newPerson   = new PersonBuilder(true).Build();
            var newPerson1  = new PersonBuilder(true).Build();
            var interpretee = new NewParticipant()
            {
                Person      = newPerson,
                CaseRole    = applicantCaseRole,
                HearingRole = applicantRepresentativeHearingRole,
                DisplayName = $"{newPerson.FirstName} {newPerson.LastName}",
                Representee = string.Empty
            };
            var interpreter = new NewParticipant()
            {
                Person      = newPerson1,
                CaseRole    = respondentCaseRole,
                HearingRole = respondentRepresentativeHearingRole,
                DisplayName = $"{newPerson.FirstName} {newPerson.LastName}",
                Representee = string.Empty
            };
            var participants = new List <NewParticipant>()
            {
                interpretee,
                interpreter
            };
            var links = new List <LinkedParticipantDto>();
            var link  = new LinkedParticipantDto(
                interpreter.Person.ContactEmail,
                interpretee.Person.ContactEmail,
                LinkedParticipantType.Interpreter
                );

            links.Add(link);

            await _commandHandler.Handle(new AddParticipantsToVideoHearingCommand(_newHearingId, participants, links));

            var returnedVideoHearing =
                await _getHearingByIdQueryHandler.Handle(new GetHearingByIdQuery(seededHearing.Id));

            returnedVideoHearing.Participants.Where(x => x.LinkedParticipants.Any()).Should().NotBeNull();
        }
 public static LinkedParticipantRequest MapToLinkedParticipantRequest(LinkedParticipantDto linkedParticipantDto)
 {
     return(new LinkedParticipantRequest
     {
         ParticipantRefId = linkedParticipantDto.ParticipantId,
         LinkedRefId = linkedParticipantDto.LinkedId,
         Type = Enum.Parse <LinkedParticipantType>(linkedParticipantDto.Type.ToString())
     });
 }
        private static ParticipantDto CreateParticipantDtoWithLinkedParticipants()
        {
            var participant       = CreateParticipantDtoWithoutLinkedParticipants();
            var linkedParticipant = new LinkedParticipantDto
            {
                LinkedId      = Guid.NewGuid(),
                ParticipantId = participant.ParticipantId,
                Type          = LinkedParticipantType.Interpreter
            };

            participant.LinkedParticipants = new List <LinkedParticipantDto> {
                linkedParticipant
            };
            return(participant);
        }
        public static List <LinkedParticipantDto> MapToDto(List <LinkedParticipantRequest> requests)
        {
            var listOfDtos = new List <LinkedParticipantDto>();

            if (requests != null)
            {
                foreach (var request in requests)
                {
                    var dto = new LinkedParticipantDto(request.ParticipantContactEmail,
                                                       request.LinkedParticipantContactEmail, request.Type.MapToDomainEnum());
                    listOfDtos.Add(dto);
                }
            }

            return(listOfDtos);
        }