public void CompleteFurtherControlMeasureTask(CompleteTaskRequest request)
        {
            _log.Add(request);
            var userForAuditing = _userForAuditingRepository.GetByIdAndCompanyId(request.UserId, request.CompanyId); 
            var user = _userRepository.GetByIdAndCompanyId(request.UserId, request.CompanyId);
            var furtherControlMeasureTask = _taskRepository.GetByIdAndCompanyId(request.FurtherControlMeasureTaskId, request.CompanyId);
            var createDocumentParameterObjects = _documentParameterHelper.GetCreateDocumentParameters(request.CreateDocumentRequests, request.CompanyId);

            furtherControlMeasureTask.Complete(request.CompletedComments, createDocumentParameterObjects
                , request.DocumentLibraryIdsToDelete, userForAuditing, user, request.CompletedDate);

            _taskRepository.SaveOrUpdate(furtherControlMeasureTask);
        }
        public JsonResult CompleteTask(CompleteTaskViewModel completeTaskViewModel, DocumentsToSaveViewModel documentsToSaveViewModel)
        {
            if (!ModelState.IsValid)
            {
                throw new ArgumentException("Invalid Arguments To Complete Task");
            }

            var request = new CompleteTaskRequest
                              {
                                  CompanyId = completeTaskViewModel.CompanyId,
                                  FurtherControlMeasureTaskId = completeTaskViewModel.FurtherControlMeasureTaskId,
                                  CompletedComments = completeTaskViewModel.CompletedComments,
                                  UserId = CurrentUser.UserId,
                                  CreateDocumentRequests = documentsToSaveViewModel.CreateDocumentRequests,
                                  DocumentLibraryIdsToDelete = documentsToSaveViewModel.DeleteDocumentRequests,
                                  CompletedDate = DateTimeOffset.Now
                              };

            using (var session = _businessSafeSessionManager.Session)
            {
                _furtherControlMeasureTaskService.CompleteFurtherControlMeasureTask(request);
                _businessSafeSessionManager.CloseSession();
            }

            using (var session = _businessSafeSessionManager.Session)
            {
                _furtherControlMeasureTaskService.SendTaskCompletedEmail(request);
                 _businessSafeSessionManager.CloseSession();
            }

            return Json(new SaveTaskResultViewModel
            {
                Success = true,
                Id = completeTaskViewModel.FurtherControlMeasureTaskId,
            });
        }
        /// <summary>
        /// Will send the SendTaskCompletedEmail to the bus for processing if task completed notification is required and risk assessor has an email address
        /// </summary>
        /// <param name="request"></param>
        public void SendTaskCompletedEmail(CompleteTaskRequest request)
        {
            var task = (Task) _taskRepository.GetByIdAndCompanyId(request.FurtherControlMeasureTaskId,
                                                                             request.CompanyId);
            if (task.IsTaskCompletedNotificationRequired())
            {
                _bus.Send(new SendTaskCompletedEmail
                {
                    TaskReference = task.Reference,
                    Title = task.Title,
                    Description = task.Description,
                    RiskAssessorName = task.RiskAssessment.RiskAssessor.Employee.FullName,
                    RiskAssessorEmail = task.RiskAssessment.RiskAssessor.Employee.MainContactDetails != null ? task.RiskAssessment.RiskAssessor.Employee.MainContactDetails.Email : null,
                    TaskAssignedTo = task.TaskAssignedTo != null ? task.TaskAssignedTo.FullName : string.Empty
                });
            }

        }
        public void Given_further_control_measure_task_exists_when_Completed_then_correct_values_are_passed_to_the_complete_task_method()
        {
            //given
            var request = new CompleteTaskRequest()
                              {
                                  CompanyId = 123435,
                                  CompletedComments = "complete task comments test",
                                  CreateDocumentRequests = new List<CreateDocumentRequest>()
                                  ,
                                  DocumentLibraryIdsToDelete = new List<long>()
                                  ,
                                  FurtherControlMeasureTaskId = 34983
                                  ,
                                  UserId = Guid.NewGuid()
                                  ,CompletedDate = DateTimeOffset.Now.AddDays(-12)
                              };

            var auditUser = new UserForAuditing() {Id = Guid.NewGuid()};
            var bsoUser = new User() {Id = Guid.NewGuid()};

            _userForAuditingRepository.Setup(x => x.GetByIdAndCompanyId(It.IsAny<Guid>(),It.IsAny<long>())).Returns(() => auditUser);
            _userRepo.Setup(x => x.GetByIdAndCompanyId(It.IsAny<Guid>(),It.IsAny<long>())).Returns(() => bsoUser);

            var task = new Mock<MultiHazardRiskAssessmentFurtherControlMeasureTask>();
            task.Setup(x => x.Complete(It.IsAny<string>()
                                       , It.IsAny<IEnumerable<CreateDocumentParameters>>()
                                       , It.IsAny<IEnumerable<long>>()
                                       , It.IsAny<UserForAuditing>()
                                       , It.IsAny<User>()
                                       , It.IsAny<DateTimeOffset>()))
                .Callback<string, IEnumerable<CreateDocumentParameters>, IEnumerable<long>, UserForAuditing, User, DateTimeOffset >(
                    (comments, createDocumentParameters, docLibIdsToRemove, userForAuditing, user, completedDate)  =>
                        {
                            Assert.AreEqual(request.CompletedComments, comments);
                            Assert.AreEqual(request.CreateDocumentRequests, createDocumentParameters);
                            Assert.AreEqual(request.DocumentLibraryIdsToDelete, docLibIdsToRemove);
                            Assert.AreEqual(auditUser.Id, userForAuditing.Id);
                            Assert.AreEqual(request.CompletedDate, completedDate);
                            Assert.AreEqual(bsoUser.Id, user.Id);
                        });

            _furtherControlMeasureTaskRepository.Setup(x => x.GetByIdAndCompanyId(It.IsAny<long>(), It.IsAny<long>()))
                .Returns(() => task.Object);

            var target = GetTarget();

            target.CompleteFurtherControlMeasureTask(request);

        }