public async Task <Employee> CreateEmployeeAsync(EmploymentViewModel employee)
{
try
{
//check if the person is already emplyment
var results = (await _repository.SearchAsync <Employee>(c => c.PersonId == employee.PersonId)).FirstOrDefault();
if (results == null)
{
var _employee = Mapper.Map(new Employee(), employee);
_employee.LevelTypeId = employee.LevelType.LevelTypeId;
_employee.LevelType = null;
var entity = await _repository.AddEntityAsync(_employee);
return(entity);
}
else
{
throw new Exception("This person is already employed");
}
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public async Task <EmploymentViewModel> CreateTaskAsnyc(EmploymentViewModel employmentViewModel)
{
try
{
if (CheckIntervals(employmentViewModel.EmployeeId, employmentViewModel.HourWorked) == true)
{
employmentViewModel.Duration = TimeSpan.FromHours(employmentViewModel.HourWorked);
var _task = Mapper.Map(new TaskType(), employmentViewModel);
var levelId = _repository.Search <Employee>(c => c.EmployeeId == employmentViewModel.EmployeeId).FirstOrDefault().LevelTypeId;
var price = _repository.Search <LevelType>(c => c.LevelTypeId == levelId).
FirstOrDefault().Price;
_task.RatePerHour = price;
var results = await _repository.AddEntityAsync(_task);
return(Mapper.Map(new EmploymentViewModel(), results));
}
else
{
throw new Exception("Your tasks are exceeding 12 Hours");
}
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
public async Task <IActionResult> Create(EmploymentViewModel model)
{
var employment = Mapper.Map <Employment>(model);
await _proxy.CreateEmployment(employment);
return(Ok());
}
public async Task <IActionResult> Edit(EmploymentViewModel model)
{
var emp = Mapper.Map <Employment>(model);
await _proxy.UpdateEmploymentAsync(emp);
return(Ok());
}
public ActionResult AddEmploymentInformationSend(EmploymentViewModel eVM)
{
if (ModelState.IsValid)
{
Person p = Session["Person"] as Person;
Employment e = hrServices.CreateEmployment(eVM, p);
if (e != null)
{
return(RedirectToAction("AddContactPerson"));
}
else
{
ModelState.AddModelError("", "Nieznany blad");
return(View("AddEmploymentInformation", eVM));
}
}
else
{
eVM.Positions = hrServices.PositionsSelectListItem();
eVM.Organizations = hrServices.OrganizationalUnitSelectListItem();
eVM.ListOfManagers = hrServices.GetAllManagersSelectList();
return(View("AddEmploymentInformation", eVM));
}
}
public ActionResult Employment(int?clientId)
{
int resolvedClientId = this.ResolveClientId(clientId);
EmploymentViewModel model = this.clientProfileManager.GetEmploymentViewModel(resolvedClientId);
return(this.View(model));
}
public void SaveEmployment(EmploymentViewModel model)
{
EmploymentData employment = this.clientProfileService.GetClientEmploymentData(model.ClientId);
employment.Company = model.Company;
employment.HireDate = model.HireDate;
employment.Position = model.Position;
employment.Salary = model.Salary;
employment.IsUnemployed = model.IsUnemployed;
this.clientProfileService.Save(employment);
}
public double CalculateSalary(EmploymentViewModel employmentViewModel)
{
var total = 0.0;
var tasks = _repository.Search <TaskType>(c => c.EmployeeId == employmentViewModel.EmployeeId).ToList();
foreach (var item in tasks)
{
total += item.RatePerHour;
}
return(total);
}
public ActionResult Employment(EmploymentViewModel model)
{
if (!this.ModelState.IsValid)
{
return(this.View(model));
}
model.ClientId = this.ResolveClientId(model.ClientId);
this.clientProfileManager.SaveEmployment(model);
return(this.RedirectToAction("Obligations", new { clientId = model.ClientId }));
}
public async Task <IActionResult> GetEmployTable()
{
var employ = await _getEmployment.GetEmployTable();
var employmentViewModel = new EmploymentViewModel()
{
EmploymentTables = employ,
Title = "Employment Options"
};
return(View(employmentViewModel));
}
public ActionResult AddEmploymentInformation()
{
EmploymentViewModel eVM = new EmploymentViewModel();
eVM.Positions = hrServices.PositionsSelectListItem();
eVM.Organizations = hrServices.OrganizationalUnitSelectListItem();
eVM.ListOfManagers = hrServices.GetAllManagersSelectList();
/*eVM.Positions = new List<SelectListItem> { new SelectListItem{Text = "Java Developer", Value="1"} } ;
* eVM.Organizations = new List<SelectListItem> { new SelectListItem { Text = "JAVA TEAM", Value = "1" } };*/
return(View(eVM));
}
public async Task <IActionResult> Employment()
{
var getEmp = new GetEmployment();
var Empl = await getEmp.GetEmpTable();
var gradViewModel = new EmploymentViewModel()
{
Emp = Empl,
Title = "Employment History"
};
return(View(gradViewModel));
}
public async Task <Employee> UpdateEmployeeAsync(EmploymentViewModel employee)
{
try
{
var _employee = Mapper.Map(new Employee(), employee);
var results = await _repository.UpdateEntityAsync(_employee);
return(results);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public async Task <EmploymentViewModel> UpdateTaskAsnyc(EmploymentViewModel employmentViewModel)
{
try
{
var _task = Mapper.Map(new TaskType(), employmentViewModel);
var results = await _repository.UpdateEntityAsync(_task);
return(Mapper.Map(new EmploymentViewModel(), results));
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
public IActionResult GetTaskById(int taskId)
{
var task = _taskHandler.GetTaskById(taskId);
var empVM = new EmploymentViewModel {
EmployeeId = task.EmployeeId,
LevelTypeId = task.TaskTypeId,
HourWorked = task.Duration.Hours,
Description = task.Description,
RatePerHour = task.RatePerHour,
TaskTypeId = task.TaskTypeId
};
return(PartialView("_UpdateTaskPartial", empVM));
}
//Decrypt
public static ProfileViewModel DecryptProfile(ProfileViewModel profile)
{
profile.Firstname = StringCipher.Decrypt(profile.Firstname, EncryptKey);
profile.Lastname = StringCipher.Decrypt(profile.Lastname, EncryptKey);
profile.HomeLatitude = StringCipher.Decrypt(profile.HomeLatitude, EncryptKey);
profile.HomeLongitude = StringCipher.Decrypt(profile.HomeLongitude, EncryptKey);
for (int i = 0; i < profile.Employments.Count(); i++)
{
EmploymentViewModel e = profile.Employments.ElementAt(i);
e = DecryptEmployment(e);
}
return(profile);
}
public async Task <IActionResult> Employment()
{
//populate it with the api call to coop table and need to build the view and model
var getallemploy = new GetEmploymentInfo();
var employment = await getallemploy.EmploymentInfo();
var sortedEmployment = employment.OrderBy(f => f.city);
var employViewModel = new EmploymentViewModel()
{
Employment = sortedEmployment.ToList(),
Title = "Where our students work"
};
return(View(employViewModel));
}
public EmploymentViewModel GetEmploymentViewModel(int clientId)
{
EmploymentData employmentData = this.clientProfileService.GetClientEmploymentData(clientId);
var model = new EmploymentViewModel
{
ClientId = clientId,
IsUnemployed = employmentData.IsUnemployed,
Company = employmentData.Company,
HireDate = employmentData.HireDate,
Position = employmentData.Position,
Salary = employmentData.Salary
};
return(model);
}
public async Task <IActionResult> Employment()
{
var empInfo = await _empRepository.GetEmpInfo();
var coopInfo = await _empRepository.GetCoopInfo();
var gradViewModel = new EmploymentViewModel()
{
EmpInfo = empInfo,
CoopInfo = coopInfo,
Title = "Employment Table"
};
return(View(gradViewModel));
}
public async Task <IActionResult> UpdateTask(EmploymentViewModel employmentViewModel)
{
try
{
var results = await _taskHandler.UpdateTaskAsnyc(employmentViewModel);
return(RedirectToAction("Tasks", "Task", new EmploymentViewModel {
EmployeeId = results.EmployeeId
}));
}
catch (Exception ex)
{
ViewBag.ErrorMessage = ex.Message;
return(RedirectToAction("Tasks", "Task", new EmploymentViewModel()));
}
}
public IActionResult Employment(EmploymentViewModel employmentViewModel)
{
try
{
ViewData["Levels"] = new SelectList(_levelHandler.LevelTypes.Select(u =>
new SelectListItem()
{
Value = u.LevelTypeId.ToString(), Text = $"{u.Description }"
}), "Value", "Text");
return(View(employmentViewModel));
}
catch (Exception ex)
{
ViewBag.ErrorMessage = ex.Message;
return(View(employmentViewModel));
}
}
public ActionResult Edit(int personnelId, int?employmentId)
{
int organisationId = UserOrganisationId;
if (employmentId == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var employment = HRBusinessService.RetrievePersonnelEmployment(organisationId, personnelId, employmentId.Value);
if (employment == null)
{
return(HttpNotFound());
}
var workingPatternDays = HRBusinessService.RetrieveWorkingPattern(UserOrganisationId, employment.WorkingPatternId.Value)?.WorkingPatternDays.ToList();
var absencePolices = HRBusinessService.RetrieveAbsencePolices(organisationId);
var publicHolidayPolices = HRBusinessService.RetrievePublicHolidayPolices(organisationId);
var companyBuilding = HRBusinessService.RetrieveEmploymentCompanyBuilding(organisationId);
var employmentTypes = HRBusinessService.RetrieveEmploymentTypes(organisationId);
var jobTitleJobgrades = HRBusinessService.RetrieveJobTitleJobGrade(organisationId).ToList();
var defaultSelectedJobTitleJobgrades = jobTitleJobgrades.FirstOrDefault(e => e.JobTitleId == employment.JobTitleId && e.JobGradeId == employment.JobGradeId);
var viewModel = new EmploymentViewModel
{
AbsencePolicyName = absencePolices.FirstOrDefault(s => s.AbsencePolicyId == employment.AbsencePolicyId).Name,
AbsencePolicy = new SelectList(absencePolices, "AbsencePolicyId", "Name", employment.AbsencePolicyId),
PublicHolidayPolicy = new SelectList(publicHolidayPolices, "PublicHolidayPolicyId", "Name", employment.PublicHolidayPolicyId),
EmploymentType = new SelectList(employmentTypes, "EmploymentTypeId", "Name", employment.EmploymentTypeId),
ReportsTo = new SelectList(HRBusinessService.RetrieveReportsToPersonnel(organisationId, employment.PersonnelId), "PersonnelId", "Fullname", employment.ReportsToPersonnelId),
Employment = employment,
SelectedDepartmentIds = employment.EmploymentDepartments.Select(d => d.DepartmentId).ToList(),
SelectedTeamIds = employment.EmploymentTeams.Select(t => t.TeamId).ToList(),
SelectedCompanyId = employment.CompanyId.ToString(),
SelectedBuildingId = employment.BuildingId.ToString(),
EmploymentCompanyBuildinglist = companyBuilding,
WorkingPatternDays = workingPatternDays,
PreviousEmployment = HRBusinessService.RetrievePersonnelCurrentEmployment(organisationId, employment.PersonnelId),
AbsencePolicyHasAbsence = HRBusinessService.AbsencePolicyPersonnelEmploymentHasAbsences(organisationId, employment.EmploymentId, employment.AbsencePolicyId),
JobTitleJobGrades = jobTitleJobgrades,
SelectedJobTitleId = defaultSelectedJobTitleJobgrades.JobTitle.JobTitleId.ToString(),
SelectedJobGradeId = defaultSelectedJobTitleJobgrades.JobGrade.JobGradeId.ToString(),
PreviousAbsencePolicyId = employment.AbsencePolicyId
};
return(View(viewModel));
}
public ActionResult EmploymentForm(int id)
{
var employmentInformation = _context.EmploymentInformations.SingleOrDefault(e => e.Id == id);
var employmentType = GetEmploymentTypes();
var employmentRank = _context.EmploymentRanks.ToList();
var employmentBussinesType = _context.NatureOfBusinesses.ToList();
var viewmodel = new EmploymentViewModel
{
EmploymentInformations = employmentInformation,
EmploymentTypes = employmentType,
EmploymentRanks = employmentRank,
NatureOfBusinesses = employmentBussinesType
};
return(View(viewmodel));
}
public ActionResult Create(EmploymentViewModel employmentViewModel)
{
var organisationId = UserOrganisationId;
if (employmentViewModel.Employment.StartDate <= employmentViewModel.PreviousEmploymentEndDate)
{
ModelState.AddModelError("EmploymentError", "Employment start date should be greater than previous employment End Date");
}
if (ModelState.IsValid)
{
HRBusinessService.CreateEmployment(organisationId, employmentViewModel.Employment, employmentViewModel.WorkingPatternDays.ToList(), employmentViewModel.SelectedDepartmentIds, employmentViewModel.SelectedTeamIds);
return(RedirectToAction("Profile", "personnel", new { id = employmentViewModel.Employment.PersonnelId }));
}
var previousEmployment = HRBusinessService.RetrievePersonnelCurrentEmployment(organisationId, employmentViewModel.Employment.PersonnelId);
var absencePolices = HRBusinessService.RetrieveAbsencePolices(organisationId);
var publicHolidayPolices = HRBusinessService.RetrievePublicHolidayPolices(organisationId);
var companyBuilding = HRBusinessService.RetrieveEmploymentCompanyBuilding(organisationId).ToList();
var employmentTypes = HRBusinessService.RetrieveEmploymentTypes(organisationId);
var jobTitleJobgrades = HRBusinessService.RetrieveJobTitleJobGrade(organisationId).ToList();
var defaultSelectedJobTitleJobgrades = previousEmployment == null?jobTitleJobgrades.FirstOrDefault() : jobTitleJobgrades.FirstOrDefault(e => e.JobTitleId == employmentViewModel.PreviousEmployment.JobTitleId && e.JobGradeId == employmentViewModel.PreviousEmployment.JobGradeId);
var viewModel = new EmploymentViewModel
{
EmploymentCompanyBuildinglist = companyBuilding,
SelectedBuildingId = employmentViewModel.Employment.BuildingId.ToString(),
SelectedCompanyId = employmentViewModel.Employment.CompanyId.ToString(),
SelectedDepartmentIds = employmentViewModel.SelectedDepartmentIds,
SelectedTeamIds = employmentViewModel.SelectedTeamIds,
ReportsTo = new SelectList(HRBusinessService.RetrieveReportsToPersonnel(organisationId, employmentViewModel.Employment.PersonnelId), "PersonnelId", "Fullname"),
EmploymentType = new SelectList(employmentTypes, "EmploymentTypeId", "Name"),
AbsencePolicy = new SelectList(absencePolices, "AbsencePolicyId", "Name", previousEmployment.AbsencePolicyId),
PublicHolidayPolicy = new SelectList(publicHolidayPolices, "PublicHolidayPolicyId", "Name", previousEmployment.PublicHolidayPolicyId),
Employment = employmentViewModel.Employment,
PreviousEmployment = previousEmployment,
WorkingPatternDays = employmentViewModel.WorkingPatternDays,
JobTitleJobGrades = jobTitleJobgrades,
SelectedJobTitleId = defaultSelectedJobTitleJobgrades.JobTitle.JobTitleId.ToString(),
SelectedJobGradeId = defaultSelectedJobTitleJobgrades.JobGrade.JobGradeId.ToString(),
};
return(View(viewModel));
}
public ActionResult UpdatePreviousEmployment(EmploymentViewModel employmentViewModel)
{
int organisationId = UserOrganisationId;
if (ModelState.IsValid)
{
var employment = employmentViewModel.PreviousEmployment;
var result = HRBusinessService.UpdateEmploymentEndDate(organisationId, employment);
if (!result.Succeeded)
{
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error);
return(View(employmentViewModel));
}
}
}
return(RedirectToAction("Create", new { id = employmentViewModel.PreviousEmployment.PersonnelId }));;
}
public ActionResult Edit(EmploymentViewModel employmentViewModel)
{
var organisationId = UserOrganisationId;
if (ModelState.IsValid)
{
employmentViewModel.Employment = HRBusinessService.UpdateEmployment(organisationId, employmentViewModel.Employment, employmentViewModel.PreviousAbsencePolicyId, employmentViewModel.WorkingPatternDays, employmentViewModel.SelectedDepartmentIds,
employmentViewModel.SelectedTeamIds);
return(RedirectToAction("Profile", "Personnel", new { id = employmentViewModel.Employment.PersonnelId }));
}
var employment = HRBusinessService.RetrievePersonnelEmployment(organisationId, employmentViewModel.Employment.PersonnelId, employmentViewModel.Employment.EmploymentId);
employmentViewModel.Employment.Personnel = employment.Personnel;
var absencePolices = HRBusinessService.RetrieveAbsencePolices(organisationId);
var publicHolidayPolices = HRBusinessService.RetrievePublicHolidayPolices(organisationId);
var companyBuilding = HRBusinessService.RetrieveEmploymentCompanyBuilding(organisationId);
var employmentTypes = HRBusinessService.RetrieveEmploymentTypes(organisationId);
var jobTitleJobgrades = HRBusinessService.RetrieveJobTitleJobGrade(organisationId).ToList();
var defaultSelectedJobTitleJobgrades = jobTitleJobgrades.FirstOrDefault(e => e.JobTitleId == employmentViewModel.Employment.JobTitleId && e.JobGradeId == employmentViewModel.Employment.JobGradeId);
var viewModel = new EmploymentViewModel
{
AbsencePolicyName = absencePolices.FirstOrDefault(s => s.AbsencePolicyId == employmentViewModel.Employment.AbsencePolicyId).Name,
EmploymentCompanyBuildinglist = companyBuilding,
SelectedBuildingId = employment.BuildingId.ToString(),
SelectedCompanyId = employment.CompanyId.ToString(),
AbsencePolicy = new SelectList(absencePolices, "AbsencePolicyId", "Name", employmentViewModel.Employment.AbsencePolicyId),
PublicHolidayPolicy = new SelectList(publicHolidayPolices, "PublicHolidayPolicyId", "Name", employmentViewModel.Employment.PublicHolidayPolicyId),
ReportsTo = new SelectList(HRBusinessService.RetrieveReportsToPersonnel(organisationId, employmentViewModel.Employment.PersonnelId), "PersonnelId", "Fullname", employmentViewModel.Employment.ReportsToPersonnelId),
EmploymentType = new SelectList(employmentTypes, "EmploymentTypeId", "Name", employment.EmploymentTypeId),
Employment = employmentViewModel.Employment,
SelectedDepartmentIds = employmentViewModel.SelectedDepartmentIds,
SelectedTeamIds = employmentViewModel.SelectedTeamIds,
WorkingPatternDays = employmentViewModel.WorkingPatternDays,
AbsencePolicyHasAbsence = HRBusinessService.AbsencePolicyPersonnelEmploymentHasAbsences(organisationId, employmentViewModel.Employment.EmploymentId, employment.AbsencePolicyId),
JobTitleJobGrades = jobTitleJobgrades,
SelectedJobTitleId = defaultSelectedJobTitleJobgrades.JobTitle.JobTitleId.ToString(),
SelectedJobGradeId = defaultSelectedJobTitleJobgrades.JobGrade.JobGradeId.ToString(),
};
return(View(viewModel));
}
public async Task <IActionResult> Employment()
{
var singleFooter = new GetFooter();
var footer = await singleFooter.GetSimpleFooter();
var getEmployment = new GetEmployment();
var employment = await getEmployment.GetAllEmployment();
var employmentViewModel = new EmploymentViewModel()
{
FooterInfo = footer,
Introduction = employment.introduction,
DegreeStatistics = employment.degreeStatistics,
Employers = employment.employers,
Careers = employment.careers,
CoopTable = employment.coopTable,
EmploymentTable = employment.employmentTable,
Title = "Employment Information"
};
return(View(employmentViewModel));
}
public async Task <IActionResult> EmployementDetails(EmploymentViewModel employmentViewModel)
{
try
{
if (employmentViewModel.EmploymentType == "employee")
{
await _employeeHandler.CreateEmployeeAsync(employmentViewModel);
}
else
{
var employer = Mapper.Map(new Employer(), employmentViewModel);
await _employerHandler.CreateEmployeAsync(employer);
return(RedirectToAction("Index", "Home"));
}
return(RedirectToAction("Employees", "Employment"));
}
catch (Exception ex)
{
ViewBag.ErrorMessage = ex.Message;
return(View(new EmploymentViewModel()));
}
}
public async Task <IActionResult> UpdateEmployement(EmploymentViewModel employmentViewModel)
{
if (ModelState.IsValid)
{
try
{
if (employmentViewModel.EmploymentType == "employee")
{
await _employeeHandler.UpdateEmployeeAsync(employmentViewModel);
}
return(RedirectToAction("Employees", "Employment"));
}
catch (Exception ex)
{
ViewBag.ErrorMessage = ex.Message;
return(View(employmentViewModel));
}
}
else
{
return(View());
}
}
public ActionResult Create(int personnelId)
{
var organisationId = UserOrganisationId;
var reportsTo = HRBusinessService.RetrieveReportsToPersonnel(organisationId, personnelId);
var employmentTypes = HRBusinessService.RetrieveEmploymentTypes(organisationId);
var absencePolices = HRBusinessService.RetrieveAbsencePolices(organisationId);
var publicHolidayPolices = HRBusinessService.RetrievePublicHolidayPolices(organisationId);
var previousEmployment = HRBusinessService.RetrievePersonnelEmployments(organisationId, personnelId).OrderByDescending(s => s.StartDate).FirstOrDefault();;
var companyBuilding = HRBusinessService.RetrieveEmploymentCompanyBuilding(organisationId).ToList();
var defaultSelected = previousEmployment == null?companyBuilding.FirstOrDefault() : companyBuilding.FirstOrDefault(e => e.CompanyId == previousEmployment.CompanyId && e.BuildingId == previousEmployment.BuildingId);
var jobTitleJobgrades = HRBusinessService.RetrieveJobTitleJobGrade(organisationId).ToList();
var defaultSelectedJobTitleJobgrades = previousEmployment == null?jobTitleJobgrades.FirstOrDefault() : jobTitleJobgrades.FirstOrDefault(e => e.JobTitleId == previousEmployment.JobTitleId && e.JobGradeId == previousEmployment.JobGradeId);
var employmentViewModel = new EmploymentViewModel
{
EmploymentCompanyBuildinglist = companyBuilding,
SelectedBuildingId = defaultSelected.Building.BuildingId.ToString(),
SelectedCompanyId = defaultSelected.Company.CompanyId.ToString(),
JobTitleJobGrades = jobTitleJobgrades,
SelectedJobTitleId = defaultSelectedJobTitleJobgrades.JobTitle.JobTitleId.ToString(),
SelectedJobGradeId = defaultSelectedJobTitleJobgrades.JobGrade.JobGradeId.ToString(),
};
if (previousEmployment == null)
{
employmentViewModel.ReportsTo = new SelectList(reportsTo, "PersonnelId", "Fullname");
employmentViewModel.EmploymentType = new SelectList(employmentTypes, "EmploymentTypeId", "Name");
employmentViewModel.AbsencePolicy = new SelectList(absencePolices, "AbsencePolicyId", "Name");
employmentViewModel.PublicHolidayPolicy = new SelectList(publicHolidayPolices, "PublicHolidayPolicyId", "Name");
employmentViewModel.Employment = new Employment
{
OrganisationId = organisationId,
StartDate = DateTime.Today,
PersonnelId = personnelId,
CompanyId = defaultSelected.Company.CompanyId,
BuildingId = defaultSelected.Building.BuildingId,
JobTitleId = defaultSelectedJobTitleJobgrades.JobTitle.JobTitleId,
JobGradeId = defaultSelectedJobTitleJobgrades.JobGrade.JobGradeId,
};
employmentViewModel.WorkingPatternDays = HRBusinessService.RetrieveDefaultWorkingPatternDays();
}
else
{
employmentViewModel.ReportsTo = new SelectList(reportsTo, "PersonnelId", "Fullname",
previousEmployment.ReportsToPersonnelId);
employmentViewModel.EmploymentType = new SelectList(employmentTypes, "EmploymentTypeId", "Name", previousEmployment.EmploymentTypeId);
employmentViewModel.AbsencePolicy = new SelectList(absencePolices, "AbsencePolicyId", "Name", previousEmployment.AbsencePolicyId);
employmentViewModel.PublicHolidayPolicy = new SelectList(publicHolidayPolices, "PublicHolidayPolicyId", "Name", previousEmployment.PublicHolidayPolicyId);
employmentViewModel.SelectedDepartmentIds = HRBusinessService.RetrieveEmploymentDepartments(organisationId, previousEmployment.EmploymentId)
.Select(e => e.DepartmentId)
.ToList();
employmentViewModel.SelectedTeamIds = HRBusinessService.RetrieveEmploymentTeams(organisationId, previousEmployment.EmploymentId)
.Select(e => e.TeamId)
.ToList();
employmentViewModel.Employment = new Employment
{
StartDate = (previousEmployment.EndDate ?? new DateTime()).AddDays(1),
OrganisationId = organisationId,
PersonnelId = previousEmployment.PersonnelId,
BuildingId = previousEmployment.BuildingId,
ReportsToPersonnelId = previousEmployment.ReportsToPersonnelId,
EndEmploymentReasonId = previousEmployment.EndEmploymentReasonId,
WorkingPatternId = previousEmployment.WorkingPatternId,
CompanyId = previousEmployment.CompanyId,
AbsencePolicyId = previousEmployment.AbsencePolicyId,
PublicHolidayPolicyId = previousEmployment.PublicHolidayPolicyId,
EmploymentTypeId = previousEmployment.EmploymentTypeId,
JobGradeId = previousEmployment.JobGradeId,
JobTitleId = previousEmployment.JobTitleId,
};
employmentViewModel.PreviousEmployment = previousEmployment;
employmentViewModel.WorkingPatternDays = previousEmployment.WorkingPattern.WorkingPatternDays.ToList();
employmentViewModel.PreviousEmploymentEndDate = previousEmployment.EndDate;
}
return(View(employmentViewModel));
}