public void given_valid_company_when_getviewmodel_then_result_contains_correct_employees()
{
//given
var employeeDto = new EmployeeDto
{
Id = new Guid()
};
var employees = new List<EmployeeDto>
{
employeeDto
};
_employeeService.Setup(x => x.GetAll(It.IsAny<long>())).Returns(employees);
var factory = GetTarget();
//when
var result = factory
.WithCompanyId(1L)
.GetViewModel();
//then
Assert.That(result.Employees.Skip(1).First().value, Is.EqualTo(employeeDto.Id.ToString()));
}
public void Setup()
{
_baseAddUsersViewModel = new AddUsersViewModel
{
CompanyId = 999L,
EmployeeId = Guid.NewGuid(),
UserId = Guid.NewGuid(),
RoleId = Guid.NewGuid(),
SiteId = 10,
SiteGroupId = null
};
_baseEmployeeDto = new EmployeeDto
{
Id = _baseAddUsersViewModel.EmployeeId,
MainContactDetails = new EmployeeContactDetailDto
{
Email = "*****@*****.**",
Telephone2 = "333444555"
}
};
_employeeService = new Mock<IEmployeeService>();
_employeeService
.Setup(x => x.ValidateRegisterAsUser(It.IsAny<CreateEmployeeAsUserRequest>()))
.Returns(new ValidationResult());
_employeeService
.Setup(x => x.GetEmployee(It.IsAny<Guid>(), It.IsAny<long>()))
.Returns(_baseEmployeeDto);
_employeeService
.Setup(x => x.CreateUser(It.IsAny<CreateEmployeeAsUserRequest>()));
_newUserId = Guid.NewGuid();
_newRegistrationRequestService = new Mock<INewRegistrationRequestService>();
_newRegistrationRequestService
.Setup(x => x.RegisterNonAdminUser(It.IsAny<RegisterNonAdminUserRequest>()))
.Returns(_newUserId);
_newRegistrationRequestService
.Setup(x => x.HasEmailBeenRegistered(It.IsAny<string>()))
.Returns(false);
_userPermissionsViewModelFactory = new Mock<IAddUsersViewModelFactory>();
_userPermissionsViewModelFactory
.Setup(x => x.GetViewModel(It.IsAny<long>(), It.IsAny<Guid>(), It.IsAny<bool>(), It.IsAny<bool>()))
.Returns(new AddUsersViewModel());
_userPermissionsViewModelFactory
.Setup(x => x.WithCurrentUser(It.IsAny<ICustomPrincipal>()))
.Returns(_userPermissionsViewModelFactory.Object);
}
public void Setup()
{
_currentUserId = Guid.NewGuid();
_employee1 = new EmployeeDto()
{
FullName = "Barry Griffthes",
MainContactDetails = new EmployeeContactDetailDto { Email = "*****@*****.**" }
};
_checklist1 = new ChecklistDto()
{
Title = "Title 1"
};
var employeeChecklist1 = new EmployeeChecklistDto
{
Employee = _employee1,
Checklist = _checklist1,
CompletedDate = DateTime.Now,
Id = Guid.NewGuid(),
IsFurtherActionRequired = true
};
_employee2 = new EmployeeDto()
{
FullName = "Dave Smith",
MainContactDetails = new EmployeeContactDetailDto { Email = "*****@*****.**" }
};
_checklist2 = new ChecklistDto()
{
Title = "Title 2"
};
var employeeChecklist2 = new EmployeeChecklistDto
{
Employee = _employee2,
Checklist = _checklist2,
Id = Guid.NewGuid(),
};
_employeeChecklists = new List<EmployeeChecklistDto>
{
employeeChecklist1,
employeeChecklist2
};
_personalRiskAssessmentDto = new PersonalRiskAssessmentDto {EmployeeChecklists = _employeeChecklists, PersonalRiskAssessementEmployeeChecklistStatus = PersonalRiskAssessementEmployeeChecklistStatusEnum.Generated};
_personalRiskAssessmentService = new Mock<IPersonalRiskAssessmentService>();
}
public EmployeeDto Map(Employee employee)
{
if (employee == null)
{
return null;
}
var employeeDto = new EmployeeDto
{
Id = employee.Id,
EmployeeReference = employee.EmployeeReference,
Title = employee.Title,
Forename = employee.Forename,
Surname = employee.Surname,
MiddleName = employee.MiddleName,
PreviousSurname = employee.PreviousSurname,
Sex = employee.Sex,
DateOfBirth = employee.DateOfBirth.GetValueOrDefault(),
HasDisability = employee.HasDisability.GetValueOrDefault(),
DisabilityDescription = employee.DisabilityDescription,
SiteId = employee.Site != null ? employee.Site.Id : 0,
SiteName = employee.Site != null ? employee.Site.Name : string.Empty,
JobTitle = employee.JobTitle,
EmploymentStatusId = employee.EmploymentStatus != null ? employee.EmploymentStatus.Id : 0,
NINumber = employee.NINumber,
PassportNumber = employee.PassportNumber,
PPSNumber = employee.PPSNumber,
WorkVisaNumber = employee.WorkVisaNumber,
WorkVisaExpirationDate = employee.WorkVisaExpirationDate.HasValue ? employee.WorkVisaExpirationDate.Value : (DateTime?)null,
DrivingLicenseNumber = employee.DrivingLicenseNumber,
DrivingLicenseExpirationDate = employee.DrivingLicenseExpirationDate.HasValue ? employee.DrivingLicenseExpirationDate.Value : (DateTime?)null,
HasCompanyVehicle = employee.HasCompanyVehicle.GetValueOrDefault(),
CompanyVehicleTypeId = employee.CompanyVehicleType != null ? employee.CompanyVehicleType.Id : 0,
CompanyVehicleType = employee.CompanyVehicleType != null ? employee.CompanyVehicleType.Name : string.Empty,
CompanyVehicleRegistration = employee.CompanyVehicleRegistration,
Deleted = employee.Deleted,
FullName = employee.FullName,
CanChangeEmail = employee.CanChangeEmail,
NotificationFrequency = employee.NotificationFrequecy,
NotificationType = MapNotificationType(employee.NotificationType)
};
return employeeDto;
}
public void When_get_view_model_Then_return_correct_view_model()
{
// Given
var target = CreateViewUserViewModelFactory();
var employeeDto = new EmployeeDto()
{
FullName = "Test Name",
EmployeeReference = "Test Reference",
JobTitle = "Test JobTitle",
User = new UserDto()
{
Role = new RoleDto()
{
Name = "TestRole",
Description = "Test Role"
},
SiteStructureElement = new SiteGroupDto()
{
Name = "Test Site"
}
},
};
_employeeService
.Setup(x => x.GetEmployee(_employeeId, _companyId))
.Returns(employeeDto);
// When
var result = target
.WithCompanyId(_companyId)
.WithEmployeeId(_employeeId)
.GetViewModel();
// Then
Assert.That(result, Is.TypeOf<ViewUserViewModel>());
Assert.That(result.Name, Is.EqualTo("Test Name"));
Assert.That(result.EmployeeReference, Is.EqualTo("Test Reference"));
Assert.That(result.JobTitle, Is.EqualTo("Test JobTitle"));
Assert.That(result.Role, Is.EqualTo("Test Role"));
Assert.That(result.PermissionLevel, Is.EqualTo("Site Group - Test Site"));
}
private IEnumerable<AutoCompleteViewModel> GetNationalities(EmployeeDto employeeDto)
{
var nationalities = _lookupService
.GetNationalities()
.OrderBy(x => x.Name);
if (!nationalities.Any())
return new List<AutoCompleteViewModel>().AddDefaultOption();
var result = new List<LookupDto>
{
nationalities.First(x => x.Name == "British"),
nationalities.First(x => x.Name == "Irish")
};
result.AddRange(nationalities.Where(x => x.Name != "British" && x.Name!="Irish"));
return result.Select(AutoCompleteViewModel.ForLookUp).AddDefaultOption();
}
public static AutoCompleteViewModel ForEmployeeWithSite(EmployeeDto employeeDto)
{
return new AutoCompleteViewModel(string.Format("{0}, {1} ( {2} )", employeeDto.Surname, employeeDto.Forename, employeeDto.SiteName), employeeDto.Id.ToString());
}
public static AutoCompleteViewModel ForEmployeeNoJobTitle(EmployeeDto employeeDto)
{
return new AutoCompleteViewModel(employeeDto.FullName, employeeDto.Id.ToString());
}
public static AutoCompleteViewModel ForEmployeeWithEmail(EmployeeDto employeeDto)
{
var emailLabel = employeeDto.MainContactDetails == null || string.IsNullOrEmpty(employeeDto.MainContactDetails.Email) ? string.Empty : string.Format(" ({0})", employeeDto.MainContactDetails.Email);
return new AutoCompleteViewModel(string.Format("{0}{1}", employeeDto.FullName, emailLabel), employeeDto.Id.ToString());
}
public static AutoCompleteViewModel ForEmployee(EmployeeDto employeeDto)
{
return new AutoCompleteViewModel(string.Format("{0} ( {1} )", employeeDto.FullName, employeeDto.JobTitle), employeeDto.Id.ToString());
}
public void given_action_id_and_company_id_when_get_view_model_then_existing_documents_are_returned()
{
//given
var companyId = 123L;
var actionId = 1L;
var target = GetTarget();
var assignedTo = new EmployeeDto
{
Id = Guid.NewGuid(),
FullName = "employee'"
};
var task = new ActionTaskDto
{
Id = 1L,
Title = "Title",
Description = "Description",
TaskAssignedTo = assignedTo
};
var action = new ActionDto
{
Id = actionId,
ActionTasks = new List<ActionTaskDto>
{
task
},
};
_actionService
.Setup(x => x.GetByIdAndCompanyId( actionId, companyId ))
.Returns(action);
ExistingDocumentsViewModel existingDocumentsViewModel = new ExistingDocumentsViewModel();
existingDocumentsViewModel.PreviouslyAddedDocuments = new List<PreviouslyAddedDocumentGridRowViewModel>();
PreviouslyAddedDocumentGridRowViewModel padGridRowViewModel = new PreviouslyAddedDocumentGridRowViewModel();
padGridRowViewModel.Id = 1234L;
padGridRowViewModel.Filename = "somefilename.doc";
padGridRowViewModel.Description = "";
padGridRowViewModel.DocumentLibraryId = 765L;
padGridRowViewModel.DocumentOriginType = DocumentOriginType.TaskUpdated;
padGridRowViewModel.DocumentTypeName = "somedocumenttype";
existingDocumentsViewModel.PreviouslyAddedDocuments.Add(padGridRowViewModel);
_existingDocumentsViewModelFactory
.Setup(x => x.GetViewModel(It.IsAny<IEnumerable<TaskDocumentDto>>()))
.Returns(existingDocumentsViewModel);
var result = target
.WithCompanyId(companyId)
.WithActionId(actionId)
.GetViewModel();
// then
Assert.IsNotNull(result.ExistingDocuments);
Assert.IsNotNull(result.ExistingDocuments.PreviouslyAddedDocuments);
Assert.AreEqual( 1, result.ExistingDocuments.PreviouslyAddedDocuments.Count);
Assert.AreEqual(padGridRowViewModel.Id, result.ExistingDocuments.PreviouslyAddedDocuments[0].Id);
//Assert.AreEqual( DocumentTypeEnum.Action, result.ExistingDocuments.PreviouslyAddedDocuments[0].DocumentTypeName);
Assert.AreEqual(DocumentOriginType.TaskUpdated, result.ExistingDocuments.PreviouslyAddedDocuments[0].DocumentOriginType);
}
public void Given_risk_assessor_is_not_a_user_When_GetViewModel_Then_IsSensitiveReadonly_is_true()
{
// Given
_riskAssessment.CreatedBy = new AuditedUserDto() {Id = Guid.NewGuid()};
_riskAssessment.RiskAssessor = new RiskAssessorDto()
{
Employee = new EmployeeDto() { Id = Guid.NewGuid(), User = null}
};
var employee = new EmployeeDto();
_employeeService.Setup(x => x.GetEmployee(It.IsAny<Guid>(), It.IsAny<long>()))
.Returns(() => employee);
// When
var result = _target
.WithCompanyId(_companyId)
.WithRiskAssessmentId(_riskAssessmentId)
.WithCurrentUserId(_currentUserId)
.GetViewModel();
// Then
Assert.IsTrue(result.IsSensitiveReadonly);
}
private EmployeeDto GetEmployee()
{
var employeeDto = new EmployeeDto();
if (_employeeId.HasValue)
{
employeeDto = _employeeService.GetEmployee(_employeeId.Value, _companyId);
}
return employeeDto;
}
private void RegisterEmployeeAsUser(EmployeeDto employee, CreateEmployeeAsUserRequest request)
{
var registerNonAdminUserRequest = new RegisterNonAdminUserRequest
{
ClientId = CurrentUser.CompanyId,
PeninsulaApplicationId = Guid.Parse(ConfigurationManager.AppSettings["BSOGuid"]),
RegistrationEmail = employee.MainContactDetails.Email,
TelephoneNumber = employee.MainContactDetails.Telephone1 ?? employee.MainContactDetails.Telephone2
};
request.NewUserId = _newRegistrationRequestService.RegisterNonAdminUser(registerNonAdminUserRequest);
_employeeService.CreateUser(request);
}
public void Given_Valid_employee_details_When_Create_is_called_Then_EmployeeService_CreateUser_is_Called()
{
// Given
var controller = CreateEmployeeController();
Guid employeeId = Guid.NewGuid();
Guid userRoleId = Guid.NewGuid();
long userSiteId = 1234;
var request = EmployeeViewModelBuilder
.Create()
.WithEmployeeId(employeeId)
.WithTitle("Mr")
.WithForename("Fred")
.WithSurname("Flintstone")
.WithSex("Male")
.WithUserRoleId(userRoleId)
.WithUserSiteId(userSiteId)
.Build();
var employeeDto = new EmployeeDto
{
Id = employeeId,
MainContactDetails = new EmployeeContactDetailDto
{
Email = "*****@*****.**",
Telephone2 = "333444555"
}
};
_employeeService
.Setup(x => x.GetEmployee(It.IsAny<Guid>(), It.IsAny<long>()))
.Returns(employeeDto);
var response = new AddEmployeeResponse()
{
EmployeeId = Guid.NewGuid(),
Success = true
};
_employeeService
.Setup(x => x.Add(It.IsAny<AddEmployeeRequest>()))
.Returns(response);
// When
ActionResult result = controller.Update(request);
// Then
_employeeService.Verify( x => x.CreateUser( It.Is<CreateEmployeeAsUserRequest>(
y => y.RoleId == userRoleId
&& y.SiteId == userSiteId
&& y.EmployeeId == employeeId
)));
}
public void Given_currentUser_is_not_same_as_seletced_user_and_current_user_is_admin_When_GetViewModel_is_called_Then_CanChangeRoleDdl_is_false()
{
var userId = Guid.NewGuid();
var employeeId = Guid.NewGuid();
var customPrinciple = new Mock<ICustomPrincipal>();
customPrinciple
.Setup(x => x.UserId)
.Returns(Guid.NewGuid());
var employee = new EmployeeDto
{
Id = employeeId,
EmployeeReference = "EMP007",
FullName = "Rodger Red",
JobTitle = "Job Title 07",
User = new UserDto
{
Id = userId,
Role = new RoleDto
{
Id = Guid.NewGuid(),
Description = "User Admin"
}
}
};
_employeeService.Setup(x => x.GetEmployee(employeeId, _companyId)).Returns(employee);
var target = CreateUserPermissionsViewModelFactory();
var result = target.WithCurrentUser(customPrinciple.Object).GetViewModel(_companyId, employeeId, null, true);
Assert.That(result.CanChangeRoleDdl, Is.True);
}
public void Given_user_has_been_deleted_when_create_user_request_and_email_already_registered_then_assert_reinstate_command_not_called()
{
// Given
var controller = CreateEmployeeController();
Guid employeeId = Guid.NewGuid();
Guid userRoleId = Guid.NewGuid();
long userSiteId = 1234;
var userToUpdate = Guid.NewGuid();
var updateEmployeeRequest = EmployeeViewModelBuilder
.Create()
.WithEmployeeId(employeeId)
.WithTitle("Mr")
.WithForename("Fred")
.WithSurname("Flintstone")
.WithSex("Male")
.WithUserRoleId(userRoleId)
.WithUserSiteId(userSiteId)
.Build();
var employeeDto = new EmployeeDto
{
Id = employeeId,
MainContactDetails = new EmployeeContactDetailDto
{
Email = "*****@*****.**",
Telephone2 = "333444555"
},
User = new UserDto() { Id = userToUpdate, Role = new RoleDto() { Id = userRoleId }, SiteStructureElement = new SiteDto() { Id = userSiteId }, Deleted = true }
};
_userService
.Setup(x => x.GetByIdAndCompanyIdIncludeDeleted(It.IsAny<Guid>(), It.IsAny<long>()))
.Returns(new UserDto() { Employee = new EmployeeDto() { MainContactDetails = new EmployeeContactDetailDto() { Email = "Email" } } });
_newRegistrationRequestService
.Setup(x => x.HasEmailBeenRegistered(It.IsAny<string>()))
.Returns(true);
_employeeService
.Setup(x => x.GetEmployee(It.IsAny<Guid>(), It.IsAny<long>()))
.Returns(employeeDto);
_employeeService
.Setup(x => x.Update(It.IsAny<UpdateEmployeeRequest>()))
.Returns(() => new UpdateEmployeeResponse() { Success = true });
var result = controller.Update(updateEmployeeRequest);
// Then
_userService.Verify(x => x.ReinstateUser(It.IsAny<Guid>(), It.IsAny<long>(), It.IsAny<Guid>()), Times.Never());
}
public void Given_employee_and_updating_user_When_Create_is_called_Then_site_and_role_updated()
{
// Given
var controller = CreateEmployeeController();
Guid employeeId = Guid.NewGuid();
Guid userRoleId = Guid.NewGuid();
long userSiteId = 1234;
var userToUpdate = Guid.NewGuid();
var updateEmployeeRequest = EmployeeViewModelBuilder
.Create()
.WithEmployeeId(employeeId)
.WithTitle("Mr")
.WithForename("Fred")
.WithSurname("Flintstone")
.WithSex("Male")
.WithUserRoleId(userRoleId)
.WithUserSiteId(userSiteId)
.Build();
var employeeDto = new EmployeeDto
{
Id = employeeId,
MainContactDetails = new EmployeeContactDetailDto
{
Email = "*****@*****.**",
Telephone2 = "333444555"
},
User = new UserDto() { Id = userToUpdate, Role = new RoleDto() { Id = userRoleId}, SiteStructureElement = new SiteDto() { Id = userSiteId}}
};
_employeeService
.Setup(x => x.GetEmployee(It.IsAny<Guid>(), It.IsAny<long>()))
.Returns(employeeDto);
_employeeService
.Setup(x => x.Update(It.IsAny<UpdateEmployeeRequest>()))
.Returns(() => new UpdateEmployeeResponse() { Success = true });
SetUserRoleAndSiteRequest request = null;
_userService
.Setup(x => x.SetRoleAndSite(It.IsAny<SetUserRoleAndSiteRequest>()))
.Callback<SetUserRoleAndSiteRequest>(parameter => request = parameter);
// When
var result = controller.Update(updateEmployeeRequest);
// Then
_employeeService.Verify(x => x.CreateUser(It.IsAny<CreateEmployeeAsUserRequest>()), Times.Never());
_userService.Verify(x => x.SetRoleAndSite(It.IsAny<SetUserRoleAndSiteRequest>()), Times.Once());
Assert.That(request.RoleId, Is.EqualTo(userRoleId));
Assert.That(request.UserToUpdateId, Is.EqualTo(userToUpdate));
Assert.That(request.SiteId, Is.EqualTo(userSiteId));
// Assert.That(request.ActioningUserId, Is.EqualTo(employeeId));
Assert.That(request.CompanyId, Is.EqualTo(controller.CurrentUser.CompanyId));
}
public void Given_employee_and_new_user_When_Create_is_called_Then_user_is_created()
{
// Given
var controller = CreateEmployeeController();
Guid employeeId = Guid.NewGuid();
Guid userRoleId = Guid.NewGuid();
long userSiteId = 1234;
var updateEmployeeRequest = EmployeeViewModelBuilder
.Create()
.WithEmployeeId(employeeId)
.WithTitle("Mr")
.WithForename("Fred")
.WithSurname("Flintstone")
.WithSex("Male")
.WithUserRoleId(userRoleId)
.WithUserSiteId(userSiteId)
.Build();
updateEmployeeRequest.CompanyId = 1;
var employeeDto = new EmployeeDto
{
Id = employeeId,
MainContactDetails = new EmployeeContactDetailDto
{
Email = "*****@*****.**",
Telephone2 = "333444555"
}
};
_employeeService
.Setup(x => x.GetEmployee(It.IsAny<Guid>(), It.IsAny<long>()))
.Returns(employeeDto);
_employeeService
.Setup(x => x.Update(It.IsAny<UpdateEmployeeRequest>()))
.Returns(() => new UpdateEmployeeResponse() {Success = true});
CreateEmployeeAsUserRequest request = null;
_employeeService
.Setup(x => x.CreateUser(It.IsAny<CreateEmployeeAsUserRequest>()))
.Callback<CreateEmployeeAsUserRequest>(parameter => request = parameter);
// When
var result = controller.Update(updateEmployeeRequest);
// Then
Assert.That(request.RoleId, Is.EqualTo(userRoleId));
Assert.That(request.SiteId, Is.EqualTo(userSiteId));
Assert.That(request.EmployeeId, Is.EqualTo(employeeId));
Assert.That(request.CompanyId, Is.EqualTo(controller.CurrentUser.CompanyId));
}
public void given_company_id_when_get_view_model_then_get_viewmodel_maps_corect_result()
{
//given
var companyId = 123L;
var actionPlanId = 1231L;
var actionId = 1L;
var assignedTo = new EmployeeDto
{
Id = Guid.NewGuid(),
FullName = "employee'"
};
var task = new ActionTaskDto
{
Id = 1L,
Title = "Title",
Description = "Description",
TaskAssignedTo = assignedTo
};
var action = new ActionDto
{
Id = actionId,
ActionTasks = new List<ActionTaskDto>
{
task
},
GuidanceNote = "1.1"
};
var target = GetTarget();
_actionService.
Setup(x => x.GetByIdAndCompanyId(It.Is<long>(a => a == actionId), It.Is<long>(c => c == companyId))).
Returns(action);
//when
var result = target
.WithCompanyId(companyId)
.WithActionPlanId(actionPlanId)
.WithActionId(actionId)
.GetViewModel();
//then
Assert.That(result.ActionPlanId, Is.EqualTo(actionPlanId));
Assert.That(result.ActionId, Is.EqualTo(action.Id));
Assert.That(result.CompanyId, Is.EqualTo(companyId));
Assert.That(result.Title, Is.EqualTo(task.Title));
Assert.That(result.Description, Is.EqualTo(task.Description));
Assert.That(result.GuidanceNotes, Is.EqualTo(action.GuidanceNote));
Assert.That(result.DueDate, Is.EqualTo(task.TaskCompletionDueDate));
Assert.That(result.ActionTaskAssignedTo, Is.EqualTo(task.TaskAssignedTo.FullName));
Assert.That(result.ActionTaskAssignedToId, Is.EqualTo(task.TaskAssignedTo.Id));
}
private IEnumerable<AutoCompleteViewModel> GetCountries(EmployeeDto employeeDto)
{
var countries = _lookupService.GetCountries();
return AutoCompleteViewModel.ForCountries(countries);
}
public void Given_SendTaskNofication_is_false_then_DoNotSendTaskAssignedNotification_equals_true()
{
//given
var assignedTo = new EmployeeDto
{
Id = Guid.NewGuid(),
FullName = "employee'"
};
var task = new ActionTaskDto
{
Id = 1L,
Title = "Title",
Description = "Description",
TaskAssignedTo = assignedTo,
SendTaskNotification = false
};
var action = new ActionDto
{
Id = 234234,
ActionTasks = new List<ActionTaskDto>
{
task
}
};
var target = GetTarget();
_actionService.
Setup(x => x.GetByIdAndCompanyId(It.IsAny<long>(), It.IsAny<long>())).
Returns(action);
//when
var result = target
.WithCompanyId(123)
.WithActionId(1123)
.GetViewModel();
//then
Assert.That(result.DoNotSendTaskAssignedNotification, Is.EqualTo(true));
}
public EmployeeMapperFactory(Employee employee)
{
_employee = employee;
_employeeDto = new EmployeeDto
{
Id = _employee.Id,
EmployeeReference = _employee.EmployeeReference,
Title = _employee.Title,
Forename = _employee.Forename,
Surname = _employee.Surname,
MiddleName = _employee.MiddleName,
PreviousSurname = _employee.PreviousSurname,
Sex = _employee.Sex,
DateOfBirth = _employee.DateOfBirth.GetValueOrDefault(),
HasDisability = _employee.HasDisability.GetValueOrDefault(),
DisabilityDescription = _employee.DisabilityDescription,
SiteId = _employee.Site != null ? _employee.Site.Id : 0,
SiteName = _employee.Site != null ? _employee.Site.Name : string.Empty,
JobTitle = _employee.JobTitle,
EmploymentStatusId = _employee.EmploymentStatus != null ? _employee.EmploymentStatus.Id : 0,
NINumber = _employee.NINumber,
PassportNumber = _employee.PassportNumber,
PPSNumber = _employee.PPSNumber,
WorkVisaNumber = _employee.WorkVisaNumber,
WorkVisaExpirationDate = _employee.WorkVisaExpirationDate.HasValue ? _employee.WorkVisaExpirationDate.Value : (DateTime?) null,
DrivingLicenseNumber = _employee.DrivingLicenseNumber,
DrivingLicenseExpirationDate = _employee.DrivingLicenseExpirationDate.HasValue ? _employee.DrivingLicenseExpirationDate.Value : (DateTime?) null,
HasCompanyVehicle = _employee.HasCompanyVehicle.GetValueOrDefault(),
CompanyVehicleTypeId = _employee.CompanyVehicleType != null ? _employee.CompanyVehicleType.Id : 0,
CompanyVehicleType = _employee.CompanyVehicleType != null ? _employee.CompanyVehicleType.Name : string.Empty,
CompanyVehicleRegistration = _employee.CompanyVehicleRegistration,
Deleted = _employee.Deleted,
FullName = _employee.FullName,
CanChangeEmail = _employee.CanChangeEmail,
};
}
private bool RegistrationAttemptIsValid(EmployeeDto employee, CreateEmployeeAsUserRequest createEmployeeAsUserRequest)
{
var validationResult = _employeeService.ValidateRegisterAsUser(createEmployeeAsUserRequest);
if (!validationResult.IsValid)
{
foreach (var error in validationResult.Errors)
{
ModelState.AddModelError(error.PropertyName, error.ErrorMessage);
}
return false;
}
if (_newRegistrationRequestService.HasEmailBeenRegistered(employee.MainContactDetails.Email))
{
ModelState.AddModelError(
string.Empty,
"Sorry you are unable to create this User: the email address has already been registered"
);
return false;
}
return true;
}
private static bool IsBusinessSafeUser(EmployeeDto employee)
{
return employee.User != null && employee.User.Id != Guid.Empty;
}
