public void Given_Sensitive_and_risk_assessor_is_current_user_return_true()
        {
            var currentUserId = Guid.NewGuid();

            // Given
            var target = new PersonalRiskAssessment
            {
                Sensitive = true,
                RiskAssessor = new RiskAssessor()
                {
                    Employee = new Employee()
                    {
                        User = new User()
                        {
                            Id = currentUserId
                        }
                    }
                }
            };

            // When
            var result = target.CanUserAccess(currentUserId);

            // Then
            Assert.IsTrue(result);
        }
        public void Setup()
        {
            _log = new Mock<IPeninsulaLog>();
            _personalRiskAssessmentRepository = new Mock<IPersonalRiskAssessmentRepository>();
            _riskAssessmentRepository = new Mock<IRiskAssessmentRepository>();
            _userRepository = new Mock<IUserForAuditingRepository>();
            _employeeRepository = new Mock<IEmployeeRepository>();
            _siteRepository = new Mock<ISiteRepository>();
            _riskAssessorRepository = new Mock<IRiskAssessorRepository>();
            _checklistRepository = new Mock<IChecklistRepository>();

            _riskAssessment = new PersonalRiskAssessment() { Id = 123, CompanyId = 12312, RiskAssessmentSite = new Site() { Id = 13123 } };

            _riskAssessmentRepository
                .Setup(x => x.DoesAssessmentExistWithTheSameReference<GeneralRiskAssessment>(It.IsAny<long>(), It.IsAny<string>(), It.IsAny<long?>()))
                .Returns(false);

            _personalRiskAssessmentRepository
               .Setup(x => x.GetByIdAndCompanyId(_riskAssessment.Id, _riskAssessment.CompanyId,It.IsAny<Guid>()))
               .Returns(() => _riskAssessment);

            _siteRepository
                .Setup(x => x.GetByIdAndCompanyId(It.IsAny<long>(), It.IsAny<long>()))
                .Returns(() => _site);

            _userRepository
                .Setup(x => x.GetByIdAndCompanyId(It.IsAny<Guid>(), It.IsAny<long>()))
                .Returns(() => _user);

            _riskAssessorRepository
                .Setup(x => x.GetByIdAndCompanyId(It.IsAny<long>(), It.IsAny<long>()))
                .Returns(() => _riskAssessor);

            _target = CreatePersonalRiskAssessmentService();
        }
        public void Given_employee_when_remove_employee_from_check_list_then_generator_removes_checklist_from_list()
        {
            //given
            
            var personalRiskAssessmentService = GetTarget();
            long companyId = 1234L;
            long riskAssessmentId = 1L;
            Guid employeeId = Guid.NewGuid();
            Guid userId = Guid.NewGuid();

            var riskAssessment = new PersonalRiskAssessment
                                     {
                                         Id = 1L,
                                         ChecklistGeneratorEmployees =
                                             new List<ChecklistGeneratorEmployee>
                                                 {
                                                     new ChecklistGeneratorEmployee{Employee = new Employee{Id = employeeId}},
                                                     new ChecklistGeneratorEmployee{Employee = new Employee{Id = Guid.NewGuid()}},
                                                 }
                                     };

            _personalRiskAssessmentRepo.
                Setup(x => x.GetByIdAndCompanyId(riskAssessmentId, companyId, userId))
                .Returns(riskAssessment);

            _userRepo.Setup(x => x.GetById(userId));

            //when

            personalRiskAssessmentService.RemoveEmployeeFromCheckListGenerator(riskAssessmentId, companyId, employeeId, userId);

            //then
            Assert.That(riskAssessment.ChecklistGeneratorEmployees.Where(x=>!x.Deleted).Count(),Is.EqualTo(1));
        }
        public static PersonalRiskAssessment Create(
            string title,
            string reference,
            long clientId,
            UserForAuditing currentUser,
            string location,
            string taskProcessDescription,
            Site site,
            DateTime? assessmentDate,
            RiskAssessor riskAssessor,
            bool IsSensitive
            )
        {
            var riskAssessment = new PersonalRiskAssessment
                                     {
                                         Title = title,
                                         Reference = reference,
                                         AssessmentDate = assessmentDate,
                                         RiskAssessmentSite = site,
                                         RiskAssessor = riskAssessor,
                                         Location = location,
                                         TaskProcessDescription = taskProcessDescription,
                                         CompanyId = clientId,
                                         CreatedBy = currentUser,
                                         CreatedOn = DateTime.Now,
                                         Status = RiskAssessmentStatus.Draft,
                                         Sensitive = IsSensitive
                                     };

            return riskAssessment;
        }
        public void Given_a_PRA_when_sending_the_email_checklist_command_then_assert_that_it_has_been_sent_to_the_queue()
        {
            //given
            long riskAssId = 3248;
            var personalRiskAssessment = new PersonalRiskAssessment();
            personalRiskAssessment.Id = riskAssId;
            personalRiskAssessment.PersonalRiskAssessementEmployeeChecklistStatus = PersonalRiskAssessementEmployeeChecklistStatusEnum.NotSet;

            _log = new Mock<IPeninsulaLog>();
            _log.Setup(x => x.Add(It.IsAny<object>()));

            _userRepo = new Mock<IUserForAuditingRepository>();
            _riskAssessmentRepo = new Mock<IPersonalRiskAssessmentRepository>();
            _riskAssessmentRepo.Setup(x => x.GetById(riskAssId))
                .Returns(personalRiskAssessment);

            _employeeRepository = new Mock<IEmployeeRepository>();
            _checklistRepository = new Mock<IChecklistRepository>();

            _bus = new Mock<IBus>();
            
            var request = new GenerateEmployeeChecklistEmails { RiskAssessmentId = riskAssId };

            var target = GetTarget();

            //when
            target.SetAsGenerating(request.RiskAssessmentId);

            //then
            _bus.Verify(x => x.Send(request));
            

        }
        public void Given_personal_risk_assessment_and_employee_checklists_isnull_when_mapping_to_DTO_employee_checklists_is_empty_list()
        {
            var riskAss = new PersonalRiskAssessment();
            riskAss.EmployeeChecklists = null;

            var target = new RiskAssessmentDtoMapper();
            var riskAssDto = (PersonalRiskAssessmentDto)target.MapWithEmployeesAndNonEmployeesAndSiteAndRiskAssessor(riskAss);

            Assert.IsNotNull(riskAssDto.EmployeeChecklists);
            Assert.AreEqual(0, riskAssDto.EmployeeChecklists.Count());
        }
Beispiel #7
0
        public void When_Prefix_Then_Return_PRA()
        {
            // Given
            var target = new PersonalRiskAssessment();

            // When
            var result = target.PreFix;

            // Then
            Assert.That(result, Is.EqualTo("PRA"));
        }
        public void Given_Not_Sensitive_When_CanUserAccess_Then_return_true()
        {
            // Given
            var target = new PersonalRiskAssessment { Sensitive = false };

            // When
            var result = target.CanUserAccess(It.IsAny<Guid>());

            // Then
            Assert.IsTrue(result);
        }
        public PersonalRiskAssessmentDto MapWithChecklistGeneratorEmployeesAndChecklists(PersonalRiskAssessment entity)
        {
            var dto = new RiskAssessmentDtoMapper().MapWithEmployeesAndNonEmployeesAndSiteAndRiskAssessor(entity) as PersonalRiskAssessmentDto;

            //TODO: PTD - map this properly
            dto.ChecklistGeneratorEmployees = new EmployeeDtoMapper().MapWithNationalityAndContactDetailsAndEmergencyContactDetails(entity.ChecklistGeneratorEmployees.Select(x => x.Employee));
            
            //TODO: PTD - map this properly
            dto.Checklists = new ChecklistDtoMapper().Map(entity.Checklists.Select(x => x.Checklist));
            return dto;
        }
        public void Given_Sensitive_and_not_created_by_current_user_return_false()
        {
            var currentUser = Guid.NewGuid();

            // Given
            var target = new PersonalRiskAssessment { Sensitive = true, CreatedBy = new UserForAuditing() { Id = currentUser } };

            // When
            var result = target.CanUserAccess(Guid.NewGuid());

            // Then
            Assert.IsFalse(result);
        }
        public static PersonalRiskAssessmentDto CreateFromWithHazards(PersonalRiskAssessment riskAssessment)
        {
            var result = CreateFrom(riskAssessment);
            result.EmployeeChecklists = riskAssessment.EmployeeChecklists != null ? new EmployeeChecklistDtoMapper().Map(riskAssessment.EmployeeChecklists) : null;
            result.PersonalRiskAssessementEmployeeChecklistStatus = riskAssessment.PersonalRiskAssessementEmployeeChecklistStatus;

            foreach (var riskAssessmentHazard in riskAssessment.Hazards.OrderBy(x=> x.OrderNumber))
            {
                result.Hazards.Add(HazardDtoMapper.Map(riskAssessmentHazard));
            }

            return result;
        }
        public void Given_personal_risk_assessment_with_employee_checklists_when_mapping_to_DTO_employee_checklists_are_mapped()
        {
            var riskAss = new PersonalRiskAssessment();
            riskAss.EmployeeChecklists = new List<EmployeeChecklist>()
                                             {
                                                 new EmployeeChecklist {Id = Guid.NewGuid()}
                                                 , new EmployeeChecklist() {Id = Guid.NewGuid()}
                                             };
            
            var target = new RiskAssessmentDtoMapper();
            var riskAssDto = (PersonalRiskAssessmentDto) target.MapWithEmployeesAndNonEmployeesAndSiteAndRiskAssessor(riskAss);

            Assert.IsNotNull(riskAssDto.EmployeeChecklists);
            Assert.AreEqual(riskAss.EmployeeChecklists.Count, riskAssDto.EmployeeChecklists.Count());
        }
        public void Given_trying_to_update_reference_to_one_that_already_exists_When_Update_Summary_Then_should_throw_correct_error()
        {
            // Given
            var riskAssessment = new PersonalRiskAssessment();
            _personalRiskAssessmentRepository
                .Setup(x => x.GetByIdAndCompanyId(_request.Id, _request.CompanyId,_currentUserId))
                .Returns(riskAssessment);

            _riskAssessmentRepository
                .Setup(x => x.DoesAssessmentExistWithTheSameReference<PersonalRiskAssessment> (It.IsAny<long>(), It.IsAny<string>(), It.IsAny<long?>()))
                .Returns(true);


            var target = CreateRiskAssessmentService();
            // When
              Assert.Throws<ValidationException>(() =>target.UpdateRiskAssessmentSummary(_request));
      
        }
        public void Setup()
        {

            _employeeId = Guid.NewGuid();
            _employee = GetEmployee();
            _employeeRepository = new Mock<IEmployeeRepository>();
            _employeeRepository
                .Setup(x => x.GetByIds(new[] { _employeeId }))
                .Returns(new[] { _employee });

            _employeeChecklistEmailRepository = new Mock<IEmployeeChecklistEmailRepository>();
            _employeeChecklistRepository = new Mock<IEmployeeChecklistRepository>();

            _checklistIds = GetChecklistIds();
            _checklist = GetChecklist();
            _checklistRepository = new Mock<IChecklistRepository>();
            _checklistRepository
                .Setup(x => x.GetByIds(_checklistIds))
                .Returns(_checklist);

            _userId = Guid.NewGuid();
            _user = GetUser();
            _userRepository = new Mock<IUserForAuditingRepository>();
            _userRepository
                .Setup(x => x.GetById(_userId))
                .Returns(_user);

            

            _log = new Mock<IPeninsulaLog>();

            _personalRiskAssessment = new PersonalRiskAssessment();
            _riskAssessmentRepository = new Mock<IPersonalRiskAssessmentRepository>();
            _riskAssessmentRepository.Setup(x => x.GetById(It.IsAny<long>()))
                .Returns(() => _personalRiskAssessment);

        }
        public void When_CreateRiskAssessment_Then_Pass_Populated_RiskAssessment_To_Repo_To_Save()
        {
            // Given
            var request = new CreatePersonalRiskAssessmentRequest()
            {
                UserId = Guid.NewGuid(),
                Title = "Title",
                Reference = "Reference",
                CompanyId = 100
            };

            _userRepo
                .Setup(x => x.GetByIdAndCompanyId(It.IsAny<Guid>(), It.IsAny<long>()))
                .Returns(new UserForAuditing()
                {
                    Id = request.UserId
                });

            var passedPersonalRiskAssessment = new PersonalRiskAssessment();

            _personalRiskAssessmentRepo
                .Setup(x => x.Save(It.IsAny<PersonalRiskAssessment>()))
                .Callback<PersonalRiskAssessment>(y => passedPersonalRiskAssessment = y);

            var target = GetTarget();

            // When
            target.CreateRiskAssessment(request);

            // Then
            _personalRiskAssessmentRepo.Verify(x => x.Save(It.IsAny<PersonalRiskAssessment>()));
            Assert.That(passedPersonalRiskAssessment.Title, Is.EqualTo(request.Title));
            Assert.That(passedPersonalRiskAssessment.Reference, Is.EqualTo(request.Reference));
            Assert.That(passedPersonalRiskAssessment.CompanyId, Is.EqualTo(request.CompanyId));
            Assert.That(passedPersonalRiskAssessment.CreatedBy.Id, Is.EqualTo(request.UserId));
        }
 public PersonalRiskAssessmentDto MapWithEmployeeChecklists(PersonalRiskAssessment entity)
 {
     var dto = new RiskAssessmentDtoMapper().MapWithEmployeesAndNonEmployeesAndSiteAndRiskAssessor(entity) as PersonalRiskAssessmentDto;
     dto.EmployeeChecklists = entity.EmployeeChecklists != null ? new EmployeeChecklistDtoMapper().Map(entity.EmployeeChecklists) : null;
     return dto;
 }
        public void GeneratesExpectedEmployeeChecklistsWhenEmployeeHasEmail()
        {
            var employeeId = Guid.NewGuid();
            const string employeeEmail = "*****@*****.**";
            const string message = "Test message";
            var generatingUser = new UserForAuditing();

            var employee = new Employee
                               {
                                   Id = employeeId,
                                   Surname = "Brown",
                                   ContactDetails =
                                       new List<EmployeeContactDetail>
                                           {
                                               new EmployeeContactDetail
                                                   {
                                                       Email = employeeEmail
                                                   }
                                           }
                               };

            var employeesParameters = new List<EmployeesWithNewEmailsParameters>
                                          {
                                              new EmployeesWithNewEmailsParameters
                                                  {
                                                      Employee = employee
                                                  }
                                          };

            var checklists = new List<Checklist>
                                 {
                                     new Checklist
                                         {
                                             Id = 1L,
                                             Title = "Test Checklists 01"
                                         },
                                     new Checklist
                                         {
                                             Id = 2L,
                                             Title = "Test Checklist 01"
                                         }
                                 };

            var existingReferenceParameters = new List<ExistingReferenceParameters>
                                                  {
                                                      new ExistingReferenceParameters
                                                          {
                                                              Prefix = "BROWN",
                                                              MaxIncremental = 9
                                                          }
                                                  };

            var riskAssessment = new PersonalRiskAssessment();

            var employeeChecklistEmails = EmployeeChecklistEmail.Generate(
                employeesParameters, 
                checklists, 
                message, 
                generatingUser, 
                riskAssessment,
                false, 
                null, 
                null,
                existingReferenceParameters);

            Assert.That(employeeChecklistEmails.Count(), Is.EqualTo(1));
            Assert.That(employeeChecklistEmails[0].Id, Is.Not.Null);
            Assert.That(employeeChecklistEmails[0].Id, Is.Not.EqualTo(default(Guid)));
            Assert.That(employeeChecklistEmails[0].RecipientEmail, Is.EqualTo(employeeEmail));
            Assert.That(employeeChecklistEmails[0].Message, Is.EqualTo(message));
            Assert.That(employeeChecklistEmails[0].CreatedOn, Is.Not.Null);
            Assert.That(employeeChecklistEmails[0].CreatedOn, Is.Not.EqualTo(default(DateTime)));
            Assert.That(employeeChecklistEmails[0].CreatedBy, Is.EqualTo(generatingUser));
            Assert.That(employeeChecklistEmails[0].EmployeeChecklists.Count(), Is.EqualTo(2));
            Assert.That(employeeChecklistEmails[0].EmployeeChecklists[0].Employee, Is.EqualTo(employee));
            Assert.That(employeeChecklistEmails[0].EmployeeChecklists[0].Checklist, Is.EqualTo(checklists[0]));
            Assert.That(employeeChecklistEmails[0].EmployeeChecklists[0].Id, Is.Not.Null);
            Assert.That(employeeChecklistEmails[0].EmployeeChecklists[0].Id, Is.Not.EqualTo(default(Guid)));
            Assert.That(employeeChecklistEmails[0].EmployeeChecklists[0].StartDate, Is.Null);
            Assert.That(employeeChecklistEmails[0].EmployeeChecklists[0].CompletedDate, Is.Null);
            Assert.That(employeeChecklistEmails[0].EmployeeChecklists[0].Answers, Is.Null.Or.Empty);
            Assert.That(employeeChecklistEmails[0].EmployeeChecklists[0].CreatedOn, Is.Not.Null);
            Assert.That(employeeChecklistEmails[0].EmployeeChecklists[0].CreatedOn, Is.Not.EqualTo(default(DateTime)));
            Assert.That(employeeChecklistEmails[0].EmployeeChecklists[0].CreatedBy, Is.EqualTo(generatingUser));
            Assert.That(employeeChecklistEmails[0].EmployeeChecklists[0].FriendlyReference, Is.EqualTo("BROWN0010"));
            Assert.That(employeeChecklistEmails[0].EmployeeChecklists[1].Employee, Is.EqualTo(employee));
            Assert.That(employeeChecklistEmails[0].EmployeeChecklists[1].Checklist, Is.EqualTo(checklists[1]));
            Assert.That(employeeChecklistEmails[0].EmployeeChecklists[1].Id, Is.Not.Null);
            Assert.That(employeeChecklistEmails[0].EmployeeChecklists[1].Id, Is.Not.EqualTo(default(Guid)));
            Assert.That(employeeChecklistEmails[0].EmployeeChecklists[1].StartDate, Is.Null);
            Assert.That(employeeChecklistEmails[0].EmployeeChecklists[1].CompletedDate, Is.Null);
            Assert.That(employeeChecklistEmails[0].EmployeeChecklists[1].Answers, Is.Null.Or.Empty);
            Assert.That(employeeChecklistEmails[0].EmployeeChecklists[1].CreatedOn, Is.Not.Null);
            Assert.That(employeeChecklistEmails[0].EmployeeChecklists[1].CreatedOn, Is.Not.EqualTo(default(DateTime)));
            Assert.That(employeeChecklistEmails[0].EmployeeChecklists[1].CreatedBy, Is.EqualTo(generatingUser));
            Assert.That(employeeChecklistEmails[0].EmployeeChecklists[1].PersonalRiskAssessment, Is.EqualTo(riskAssessment));
            Assert.That(employeeChecklistEmails[0].EmployeeChecklists[1].SendCompletedChecklistNotificationEmail, Is.EqualTo(false));
            Assert.That(employeeChecklistEmails[0].EmployeeChecklists[1].CompletionNotificationEmailAddress, Is.EqualTo(null));
            Assert.That(employeeChecklistEmails[0].EmployeeChecklists[1].DueDateForCompletion, Is.EqualTo(null));
            Assert.That(employeeChecklistEmails[0].EmployeeChecklists[1].FriendlyReference, Is.EqualTo("BROWN0011"));
        }
        public void SetsEmployeeAndRecipientEmailWhenNewEmailSupplied()
        {

            const string employeeEmail = "*****@*****.**";
            const string message = "Test message";
            var generatingUser = new UserForAuditing();

            var employee = new Employee
                               {
                                   Id = Guid.NewGuid(),
                                   Surname = "White",
                                   ContactDetails = new List<EmployeeContactDetail>()
                                                        {
                                                            new EmployeeContactDetail()
                                                        }
                               };

            var employeesParameters = new List<EmployeesWithNewEmailsParameters>
                                          {
                                              new EmployeesWithNewEmailsParameters
                                                  {
                                                      Employee = employee,
                                                      NewEmail = employeeEmail
                                                  }
                                          };

            var checklists = new List<Checklist>
                                 {
                                     new Checklist
                                         {
                                             Id = 1L,
                                             Title = "Test Checklists 01"
                                         },
                                     new Checklist
                                         {
                                             Id = 2L,
                                             Title = "Test Checklist 01"
                                         }
                                 };

            var existingReferenceParameters = new List<ExistingReferenceParameters>
                                                  {
                                                      new ExistingReferenceParameters
                                                          {
                                                              Prefix = "WHITE",
                                                              MaxIncremental = 3
                                                          }
                                                  };

            var riskAssessment = new PersonalRiskAssessment();

            var employeeChecklistEmails = EmployeeChecklistEmail.Generate(
                employeesParameters, 
                checklists, message, 
                generatingUser, 
                riskAssessment, 
                null, 
                null,
                null,
                existingReferenceParameters);

            Assert.That(employeeChecklistEmails.Count(), Is.EqualTo(1));
            Assert.That(employee.ContactDetails[0].Email, Is.EqualTo(employeeEmail));
            Assert.That(employeeChecklistEmails[0].RecipientEmail, Is.EqualTo(employeeEmail));
            Assert.That(employee.ContactDetails[0].LastModifiedOn, Is.Not.Null);
            Assert.That(employee.ContactDetails[0].LastModifiedOn, Is.Not.EqualTo(default(DateTime)));
            Assert.That(employee.ContactDetails[0].LastModifiedBy, Is.EqualTo(generatingUser));
            
        }
        public void Given_When_Update_Summary_Then_the_new_reference_value_should_be_used_when_checking_to_see_if_it_exists()
        {
            // Given
            var riskAssessment = new PersonalRiskAssessment();
            riskAssessment.Id = _request.Id;
            riskAssessment.CompanyId = _request.CompanyId;
            
            _personalRiskAssessmentRepository
                .Setup(x => x.GetByIdAndCompanyId(_request.Id, _request.CompanyId, _currentUserId))
                .Returns(riskAssessment);

            _riskAssessmentRepository
                .Setup(x => x.DoesAssessmentExistWithTheSameReference<PersonalRiskAssessment>(It.IsAny<long>(), It.IsAny<string>(), It.IsAny<long?>()))
                .Returns(false);

            var target = CreateRiskAssessmentService();

            // When
            target.UpdateRiskAssessmentSummary(_request);

            _riskAssessmentRepository.Verify(x => x.DoesAssessmentExistWithTheSameReference<PersonalRiskAssessment>(_request.CompanyId, It.IsAny<string>(), It.IsAny<long?>()));
            _riskAssessmentRepository.Verify(x => x.DoesAssessmentExistWithTheSameReference<PersonalRiskAssessment>(It.IsAny<long>(), _request.Reference, It.IsAny<long?>()));
            _riskAssessmentRepository.Verify(x => x.DoesAssessmentExistWithTheSameReference<PersonalRiskAssessment>(It.IsAny<long>(), It.IsAny<string>(), _request.Id));
        }
        public void Given_Sensitive_and_reviewer_is_user_but_review_deleted_return_false()
        {
            var currentUserId = Guid.NewGuid();

            // Given
            var target = new PersonalRiskAssessment
            {
                Sensitive = true,
                Reviews = new List<RiskAssessmentReview>
                          {
                              new RiskAssessmentReview { 
                                  ReviewAssignedTo = new Employee()
                                {
                                    User = new User() { Id = currentUserId }
                                    
                                },
                                Deleted = true
                              }
                          }
            };

            // When
            var result = target.CanUserAccess(currentUserId);

            // Then
            Assert.IsFalse(result);
        }
        public void Given_employee_when_remove_employee_from_check_list__then_generator_removes_personal_risk_assessment_is_saved()
        {
            //given

            var personalRiskAssessmentService = GetTarget();
            long companyId = 1234L;
            long riskAssessmentId = 1L;
            Guid employeeId = Guid.NewGuid();
            Guid userId = Guid.NewGuid();

            var riskAssessment = new PersonalRiskAssessment
            {
                Id = 1L,
                ChecklistGeneratorEmployees =
                    new List<ChecklistGeneratorEmployee>
                                                 {
                                                     new ChecklistGeneratorEmployee{Employee = new Employee{Id = employeeId}},
                                                     new ChecklistGeneratorEmployee{Employee = new Employee{Id = Guid.NewGuid()}},
                                                 }
            };

            _personalRiskAssessmentRepo.
                Setup(x => x.GetByIdAndCompanyId(riskAssessmentId, companyId, userId))
                .Returns(riskAssessment);

            _userRepo.Setup(x => x.GetById(userId));

            _personalRiskAssessmentRepo.Setup(x=>x.Update(riskAssessment)).Verifiable();

            //when
            personalRiskAssessmentService.RemoveEmployeeFromCheckListGenerator(riskAssessmentId, companyId, employeeId, userId);

            //then
            _personalRiskAssessmentRepo.Verify();
        }
        public void GeneratesFriendlyReferenceWhenNoCurrentSimilarReferences()
        {
            var employeeId = Guid.NewGuid();
            const string employeeEmail = "*****@*****.**";
            const string message = "Test message";
            var generatingUser = new UserForAuditing();

            var employee = new Employee
            {
                Id = employeeId,
                Surname = "Brown",
                ContactDetails =
                    new List<EmployeeContactDetail>
                                           {
                                               new EmployeeContactDetail
                                                   {
                                                       Email = employeeEmail
                                                   }
                                           }
            };

            var employeesParameters = new List<EmployeesWithNewEmailsParameters>
                                          {
                                              new EmployeesWithNewEmailsParameters
                                                  {
                                                      Employee = employee
                                                  }
                                          };

            var checklists = new List<Checklist>
                                 {
                                     new Checklist
                                         {
                                             Id = 1L,
                                             Title = "Test Checklists 01"
                                         }
                                 };

            var existingReferenceParameters = new List<ExistingReferenceParameters>();

            var riskAssessment = new PersonalRiskAssessment();

            var employeeChecklistEmails = EmployeeChecklistEmail.Generate(
                employeesParameters,
                checklists,
                message,
                generatingUser,
                riskAssessment,
                false,
                null,
                null,
                existingReferenceParameters);

            Assert.That(employeeChecklistEmails[0].EmployeeChecklists[0].FriendlyReference, Is.EqualTo("BROWN0001"));
        }
        public void CanSaveForSingleEmployeeWhenEmployeeHasEmail()
        {
            const bool hasMultipleChecklistRecipients = false;
            var employeeId = Guid.NewGuid();
            const string employeeEmail = "*****@*****.**";
            const string message = "Test message";
            var currentUser = new UserForAuditing();

            var employee = new Employee
            {
                Id = employeeId,
                ContactDetails =
                    new List<EmployeeContactDetail>
                                           {
                                               new EmployeeContactDetail
                                                   {
                                                       Email = employeeEmail
                                                   }
                                           }
            };

            var employeesParameters = new List<EmployeesWithNewEmailsParameters>
                                          {
                                              new EmployeesWithNewEmailsParameters
                                                  {
                                                      Employee = employee
                                                  }
                                          };

            var checklists = new List<Checklist>
                                 {
                                     new Checklist
                                         {
                                             Id = 1L,
                                             Title = "Test Checklists 01"
                                         },
                                     new Checklist
                                         {
                                             Id = 2L,
                                             Title = "Test Checklist 01"
                                         }
                                 };

            var personalRiskAssessment = new PersonalRiskAssessment()
                                             {
                                                 ChecklistGeneratorEmployees = new List<ChecklistGeneratorEmployee>(),
                                                 Checklists = new List<PersonalRiskAssessmentChecklist>()
                                             };

            bool? sendCompletedChecklistNotificationEmail = true;
            DateTime? completionDueDateForChecklists = DateTime.Now;
            string completionNotificationEmailAddress = "*****@*****.**";

            personalRiskAssessment.SaveChecklistGenerator(
                hasMultipleChecklistRecipients,
                employeesParameters,
                checklists,
                message,
                currentUser,
                sendCompletedChecklistNotificationEmail,
                completionDueDateForChecklists,
                completionNotificationEmailAddress);

            Assert.That(personalRiskAssessment.HasMultipleChecklistRecipients, Is.EqualTo(hasMultipleChecklistRecipients));
            Assert.That(personalRiskAssessment.ChecklistGeneratorEmployees.Count(), Is.EqualTo(1));
            Assert.That(personalRiskAssessment.ChecklistGeneratorEmployees[0].Employee.Id, Is.EqualTo(employeeId));
            Assert.That(personalRiskAssessment.ChecklistGeneratorEmployees[0].Employee.ContactDetails[0].Email, Is.EqualTo(employeeEmail));
            Assert.That(personalRiskAssessment.Checklists.Count(), Is.EqualTo(2));
            Assert.That(personalRiskAssessment.Checklists.Select(x => x.Checklist).Contains(checklists[0]));
            Assert.That(personalRiskAssessment.Checklists.Select(x => x.Checklist).Contains(checklists[1]));
            Assert.That(personalRiskAssessment.ChecklistGeneratorMessage, Is.EqualTo(message));
            Assert.That(personalRiskAssessment.LastModifiedBy, Is.EqualTo(currentUser));
            Assert.That(personalRiskAssessment.LastModifiedOn, Is.Not.Null);
            Assert.That(personalRiskAssessment.LastModifiedOn, Is.Not.EqualTo(default(DateTime)));
            Assert.That(personalRiskAssessment.SendCompletedChecklistNotificationEmail, Is.EqualTo(sendCompletedChecklistNotificationEmail));
            Assert.That(personalRiskAssessment.CompletionDueDateForChecklists, Is.EqualTo(completionDueDateForChecklists));
            Assert.That(personalRiskAssessment.CompletionNotificationEmailAddress, Is.EqualTo(completionNotificationEmailAddress));
        }
        public void Given_an_employee_doesnt_have_an_email_address_and_new_email_not_specified_when_Generate_Checklist_emails_then_exception_is_thrown()
        {
            const string message = "Test message";
            var generatingUser = new UserForAuditing();

            var employee = new Employee
            {
                Id = Guid.NewGuid(),
                Surname = "Purple",
                ContactDetails = new List<EmployeeContactDetail>()
                                                        {
                                                            new EmployeeContactDetail
                                                            {
                                                                Email = string.Empty
                                                            }
                                                        }
            };

            var employeesParameters = new List<EmployeesWithNewEmailsParameters>
                                          {
                                              new EmployeesWithNewEmailsParameters
                                                  {
                                                      Employee = employee,
                                                      NewEmail = string.Empty
                                                  }
                                          };

            var checklists = new List<Checklist>
                                 {
                                     new Checklist
                                         {
                                             Id = 1L,
                                             Title = "Test Checklists 01"
                                         },
                                     new Checklist
                                         {
                                             Id = 2L,
                                             Title = "Test Checklist 01"
                                         }
                                 };

            var existingReferenceParameters = new List<ExistingReferenceParameters>
                                                  {
                                                      new ExistingReferenceParameters
                                                          {
                                                              Prefix = "PURPLE",
                                                              MaxIncremental = 4
                                                          }
                                                  };

            var riskAssessment = new PersonalRiskAssessment();
            EmployeeChecklistEmail.Generate(
                employeesParameters, 
                checklists, 
                message, 
                generatingUser, 
                riskAssessment, 
                null, 
                null, 
                null,
                existingReferenceParameters);
        }
        public void CanSaveForSingleEmployeeWhenNewEmailSuppliedForEmployee()
        {
            const bool hasMultipleChecklistRecipients = false;
            var employeeId = Guid.NewGuid();
            const string employeeEmail = "*****@*****.**";
            const string message = "Test message";
            var currentUser = new UserForAuditing();

            var employee = new Employee
            {
                Id = employeeId
            };

            var employeesParameters = new List<EmployeesWithNewEmailsParameters>
                                          {
                                              new EmployeesWithNewEmailsParameters
                                                  {
                                                      Employee = employee,
                                                      NewEmail = employeeEmail
                                                  }
                                          };

            var checklists = new List<Checklist>
                                 {
                                     new Checklist
                                         {
                                             Id = 1L,
                                             Title = "Test Checklists 01"
                                         },
                                     new Checklist
                                         {
                                             Id = 2L,
                                             Title = "Test Checklist 01"
                                         }
                                 };

            var personalRiskAssessment = new PersonalRiskAssessment()
            {
                ChecklistGeneratorEmployees = new List<ChecklistGeneratorEmployee>(),
                Checklists = new List<PersonalRiskAssessmentChecklist>()
            };

            personalRiskAssessment.SaveChecklistGenerator(
                hasMultipleChecklistRecipients,
                employeesParameters,
                checklists,
                message,
                currentUser, 
                null,
                null,
                string.Empty);

            Assert.That(personalRiskAssessment.HasMultipleChecklistRecipients, Is.EqualTo(hasMultipleChecklistRecipients));
            Assert.That(personalRiskAssessment.ChecklistGeneratorEmployees.Count(), Is.EqualTo(1));
            Assert.That(personalRiskAssessment.ChecklistGeneratorEmployees[0].Employee.Id, Is.EqualTo(employeeId));
            Assert.That(personalRiskAssessment.ChecklistGeneratorEmployees[0].Employee.ContactDetails[0].Email, Is.EqualTo(employeeEmail));
            Assert.That(personalRiskAssessment.Checklists.Count(), Is.EqualTo(2));
            Assert.That(personalRiskAssessment.Checklists.Select(x => x.Checklist).Contains(checklists[0]));
            Assert.That(personalRiskAssessment.Checklists.Select(x => x.Checklist).Contains(checklists[1]));
            Assert.That(personalRiskAssessment.ChecklistGeneratorMessage, Is.EqualTo(message));
            Assert.That(personalRiskAssessment.LastModifiedBy, Is.EqualTo(currentUser));
            Assert.That(personalRiskAssessment.LastModifiedOn, Is.Not.Null);
            Assert.That(personalRiskAssessment.LastModifiedOn, Is.Not.EqualTo(default(DateTime)));
        }
        public void Given_Sensitive_and_last_review_reviewer_is_not_user_return_false()
        {
            var currentUserId = Guid.NewGuid();

            // Given
            var target = new PersonalRiskAssessment
            {
                Sensitive = true,
                Reviews = new List<RiskAssessmentReview>
                          {
                              new RiskAssessmentReview { 
                                CreatedOn = DateTime.Now.AddDays(-5),
                                ReviewAssignedTo = new Employee()
                                {
                                    User = new User() { Id = currentUserId }
                                }
                              },
                              new RiskAssessmentReview { 
                                CreatedOn = DateTime.Now.AddDays(-3),
                                ReviewAssignedTo = new Employee()
                                {
                                    User = new User() { Id = currentUserId }
                                }
                              },
                              new RiskAssessmentReview { 
                                CreatedOn = DateTime.Now.AddDays(-1),
                                ReviewAssignedTo = new Employee()
                                {
                                    User = new User() { Id = Guid.NewGuid() }
                                }
                              }
                          }
            };

            // When
            var result = target.CanUserAccess(currentUserId);

            // Then
            Assert.IsFalse(result);
        }
 private MultiHazardRiskAssessmentFurtherControlMeasureTask CreatePRATask()
 {
     var riskAssessement = new PersonalRiskAssessment();
     var hazard = MultiHazardRiskAssessmentHazard.Create(riskAssessement, new Hazard(), null);
     return new MultiHazardRiskAssessmentFurtherControlMeasureTask() { MultiHazardRiskAssessmentHazard = hazard, SendTaskOverdueNotification = true };
 }
        public void When_CreateRiskAssessment_Then_New_RiskAssessment_Id_Is_Returned()
        {
            // Given
            var request = new CreatePersonalRiskAssessmentRequest()
            {
                UserId = Guid.NewGuid(),
                Title = "Title",
                Reference = "Reference",
                CompanyId = 100
            };

            var passedPersonalRiskAssessment = new PersonalRiskAssessment();

            _personalRiskAssessmentRepo
                .Setup(x => x.Save(It.IsAny<PersonalRiskAssessment>()))
                .Callback<PersonalRiskAssessment>(y => passedPersonalRiskAssessment = y);

            var target = GetTarget();

            // When
            var result = target.CreateRiskAssessment(request);

            // Then
            Assert.That(result, Is.EqualTo(passedPersonalRiskAssessment.Id));
        }