public FireRiskAssessmentFurtherControlMeasureTaskDto AddFurtherControlMeasureTask(SaveFurtherControlMeasureTaskRequest request)
        {
            var user = _userForAuditingRepository.GetByIdAndCompanyId(request.UserId, request.CompanyId);

            var significantFinding = _significantFindingRepository.GetById(request.SignificantFindingId);
            var employee = _employeeRepository.GetByIdAndCompanyId(request.TaskAssignedToId, request.CompanyId);
            var createDocumentParameterses = _documentParameterHelper.GetCreateDocumentParameters(request.CreateDocumentRequests, request.CompanyId);
            var taskCategory = _taskCategoryRepository.GetFireRiskAssessmentTaskCategory();

            var task = FireRiskAssessmentFurtherControlMeasureTask.Create(
                request.Reference,
                request.Title,
                request.Description,
                request.TaskCompletionDueDate,
                request.TaskStatus,
                employee,
                user,
                createDocumentParameterses,
                taskCategory,
                request.TaskReoccurringTypeId,
                request.TaskReoccurringEndDate,
                significantFinding,
                request.SendTaskNotification,
                request.SendTaskCompletedNotification,
                request.SendTaskOverdueNotification,
                request.SendTaskDueTomorrowNotification,
                request.TaskGuid
                );

            significantFinding.AddFurtherControlMeasureTask(task, user);
            _significantFindingRepository.SaveOrUpdate(significantFinding);

            return new FireRiskAssessmentFurtherControlMeasureTaskDtoMapper().MapWithAssignedToAndSignificantFinding(task);
        }
        public static SaveFurtherControlMeasureTaskRequest Create(
            string title,
            string description,
            string reference,
            string taskCompletionDueDate,
            int taskStatusId,
            long companyId,
            long riskAssessmentId,
            long significantFindingId,
            Guid taskAssignedToId,
            int taskReoccurringTypeId,
            string taskReoccurringFirstDueDate,
            DateTime? taskReoccurringEndDate,
            Guid userId,
            List<CreateDocumentRequest> createDocumentRequests,
            List<long> deleteDocumentRequests,
            bool sendTaskNotification,
            bool sendTaskCompleteNotification,
            bool sendTaskOverdueNotification,
            bool sendTaskDueTomorrowNotification,
            Guid taskGuid
            )
        {
            var request = new SaveFurtherControlMeasureTaskRequest();

            request.Title = title;
            request.Description = description;
            request.Reference = reference;
            request.TaskStatus = (TaskStatus)taskStatusId;
            request.CompanyId = companyId;
            request.RiskAssessmentId = riskAssessmentId;
            request.TaskAssignedToId = taskAssignedToId;
            request.TaskReoccurringTypeId = taskReoccurringTypeId;
            request.TaskReoccurringEndDate = taskReoccurringEndDate;
            request.UserId = userId;
            request.CreateDocumentRequests = createDocumentRequests;
            request.DocumentLibraryIdsToDelete = deleteDocumentRequests;
            request.SignificantFindingId = significantFindingId;
            request.SendTaskNotification = sendTaskNotification;
            request.SendTaskCompletedNotification = sendTaskCompleteNotification;
            request.SendTaskOverdueNotification = sendTaskOverdueNotification;
            request.SendTaskDueTomorrowNotification = sendTaskDueTomorrowNotification;
            request.TaskGuid = taskGuid;

            if (request.IsReoccurringTask)
            {
                request.TaskCompletionDueDate = string.IsNullOrEmpty(taskReoccurringFirstDueDate)
                                                    ? (DateTime?)null
                                                    : DateTime.Parse(taskReoccurringFirstDueDate);
            }
            else
            {
                request.TaskCompletionDueDate = string.IsNullOrEmpty(taskCompletionDueDate)
                                                    ? (DateTime?)null
                                                    : DateTime.Parse(taskCompletionDueDate);
            }
            return request;
        }
        public void Given_valid_request_When_AddFurtherControlMeasureTask_is_called_Then_should_call_appropiate_methods()
        {
            //Given
            var riskAssessmentService = CreateRiskAssessmentService();
            var request = new SaveFurtherControlMeasureTaskRequest
                              {
                                  Reference = "my reference",
                                  Title = "Title",
                                  Description = "my description",
                                  TaskAssignedToId = Guid.NewGuid(),
                                  CompanyId = 123L,
                                  UserId = Guid.NewGuid(),
                                  CreateDocumentRequests = new List<CreateDocumentRequest>(),
                              };

            
            var fireRiskAssessmentChecklist = new Mock<FireRiskAssessmentChecklist>();
            fireRiskAssessmentChecklist
                .Setup(x => x.FireRiskAssessment)
                .Returns(new FireRiskAssessment());

            var fireAnswer = new Mock<FireAnswer>();
            fireAnswer
                .Setup(x => x.Self)
                .Returns(fireAnswer.Object);
            fireAnswer
                .Setup(x => x.FireRiskAssessmentChecklist)
                .Returns(fireRiskAssessmentChecklist.Object);
            fireAnswer
                .Setup(x => x.Question)
                .Returns(new Question());

            var significantFinding = new Mock<SignificantFinding>();
            significantFinding
                .Setup(x => x.FireAnswer)
                .Returns(fireAnswer.Object);
            

            _significantFindingRepository
                .Setup(x => x.GetById(request.SignificantFindingId))
                .Returns(significantFinding.Object);


            var employee = new Employee();
            _employeeRepository
                .Setup(x => x.GetByIdAndCompanyId(request.TaskAssignedToId, request.CompanyId))
                .Returns(employee);

            var taskCategory = new TaskCategory();
            _taskCategoryRepository
                .Setup(x => x.GetFireRiskAssessmentTaskCategory())
                .Returns(taskCategory);

            var user = new UserForAuditing();
            _userRepository
                .Setup(x => x.GetByIdAndCompanyId(request.UserId, request.CompanyId))
                .Returns(user)
                ;

            significantFinding
                .Setup(x => x.AddFurtherControlMeasureTask(It.Is<FireRiskAssessmentFurtherControlMeasureTask>(y =>
                                                                                                              y.Reference == request.Reference &&
                                                                                                              y.Title == request.Title &&
                                                                                                              y.Description == request.Description &&
                                                                                                              y.CreatedBy == user &&
                                                                                                              y.TaskAssignedTo == employee &&
                                                                                                              y.Category == taskCategory
                                                               ), user));
            //When
            riskAssessmentService.AddFurtherControlMeasureTask(request);

            //Then
            _taskCategoryRepository.VerifyAll();
            _employeeRepository.VerifyAll();
            _userRepository.VerifyAll();
            significantFinding.VerifyAll();
            _significantFindingRepository.Verify(x => x.SaveOrUpdate(significantFinding.Object));

        }