public ActionResult Create()
{
var isAdmin = User.IsInAnyRoles("Admin");
var organisationId = UserOrganisationId;
var countries = HRBusinessService.RetrieveCountries(organisationId, null, null).Items;
var reportsTo = HRBusinessService.RetrieveReportsToPersonnel(organisationId, 0);
var employmentTypes = HRBusinessService.RetrieveEmploymentTypes(organisationId);
var absencePolices = HRBusinessService.RetrieveAbsencePolices(organisationId);
var publicHolidayPolices = HRBusinessService.RetrievePublicHolidayPolices(organisationId);
var companyBuilding = HRBusinessService.RetrieveEmploymentCompanyBuilding(organisationId);
var defaultSelected = HRBusinessService.RetrieveEmploymentCompanyBuilding(organisationId).FirstOrDefault();
var jobTitleJobgrades = HRBusinessService.RetrieveJobTitleJobGrade(organisationId).ToList();
var defaultSelectedJobTitleJobgrades = jobTitleJobgrades.FirstOrDefault();
var approvalEntityTypeAssignments = HRBusinessService.ApprovalEntityTypeAssignments(UserOrganisationId, 0);
var approvalModels = HRBusinessService.RetrieveApprovalModels(UserOrganisationId);
var permissions = HRBusinessService.RetrievePersonnelPermissions(isAdmin, UserOrganisationId, UserPersonnelId, 0);
if (defaultSelected == null)
{
ModelState.AddModelError("EmploymentError", "Assign Site Building to Company");
}
if (defaultSelectedJobTitleJobgrades == null)
{
ModelState.AddModelError("EmploymentError", "Assign JobTitle to JobGrade");
}
var viewModel = new PersonnelProfileViewModel
{
Countries = new SelectList(countries, "CountryId", "Name"),
Personnel = new Personnel
{
OrganisationId = organisationId,
DOB = DateTime.Today,
//Title = "Mr",
//Forenames = "A",
//Surname = "B",
//Email = string.Format("{0}@hr.com", Guid.NewGuid()),
//Address1 = "Address1",
//Postcode = "POST CODE",
//Telephone = "12345678",
//NINumber = "NZ1234567",
},
EmploymentViewModel = new EmploymentViewModel
{
ReportsTo = new SelectList(reportsTo, "PersonnelId", "Fullname"),
AbsencePolicy = new SelectList(absencePolices, "AbsencePolicyId", "Name"),
PublicHolidayPolicy = new SelectList(publicHolidayPolices, "PublicHolidayPolicyId", "Name"),
Employment = new Employment
{
OrganisationId = UserOrganisationId,
StartDate = DateTime.Today,
CompanyId = defaultSelected?.Company.CompanyId ?? 0,
BuildingId = defaultSelected?.Building.BuildingId ?? 0,
JobGradeId = defaultSelectedJobTitleJobgrades?.JobGradeId ?? 0,
JobTitleId = defaultSelectedJobTitleJobgrades?.JobTitleId ?? 0
},
EmploymentType = new SelectList(employmentTypes, "EmploymentTypeId", "Name"),
EmploymentCompanyBuildinglist = companyBuilding,
SelectedBuildingId = defaultSelected?.Company.CompanyId.ToString() ?? string.Empty,
JobTitleJobGrades = jobTitleJobgrades,
SelectedCompanyId = defaultSelected?.Building.BuildingId.ToString() ?? string.Empty,
SelectedJobTitleId = defaultSelectedJobTitleJobgrades?.JobTitle.JobTitleId.ToString() ?? string.Empty,
SelectedJobGradeId = defaultSelectedJobTitleJobgrades?.JobGrade.JobGradeId.ToString() ?? string.Empty,
SelectedDepartmentIds = new List <int> {
}, // HERE AS AN EXAMPLE OF PRE SELECTED DATA (ie when editing)
SelectedTeamIds = new List <int> {
} // HERE AS AN EXAMPLE OF PRE SELECTED DATA (ie when editing)
},
ApprovalEntityTypeAssignments = approvalEntityTypeAssignments,
ApprovalModels = approvalModels,
Permissions = permissions
};
return(View(viewModel));
}
public ActionResult UnassignedAbsencePeriods(int absencePolicyId)
{
return(this.JsonNet(HRBusinessService.RetrieveUnassignedAbsencePolicyPeriods(UserOrganisationId, absencePolicyId)));
}
public ActionResult IsAbsencesAssignedToAbsencePolicyPeriod(int absencePolicyPeriodId)
{
return(this.JsonNet(HRBusinessService.IsAbsencesAssignedToAbsencePolicyPeriod(UserOrganisationId, absencePolicyPeriodId)));
}
public ActionResult CanDeleteAbsencePolicy(int absencePolicyId)
{
var result = HRBusinessService.CanDeleteAbsencePolicy(UserOrganisationId, absencePolicyId);
return(this.JsonNet(result));
}
public ActionResult AbsencePeriods(int absencePolicyId, Paging paging, List <OrderBy> orderBy)
{
return(this.JsonNet(HRBusinessService.RetrieveAbsencePolicyAbsencePeriods(UserOrganisationId, absencePolicyId, orderBy, paging)));
}
public ActionResult List(int personnelId)
{
return(this.JsonNet(HRBusinessService.RetrievePersonnelEmployments(UserOrganisationId, personnelId)));
}
public ActionResult AbsencePolicyEntitlements(int absencePolicyId)
{
return(this.JsonNet(HRBusinessService.RetrieveAbsencePolicyEntitlements(UserOrganisationId, absencePolicyId)));
}
public ActionResult UnassignSiteBuilding(int companybuildingId)
{
HRBusinessService.DeleteCompanyBuilding(UserOrganisationId, companybuildingId);
return(this.JsonNet(""));
}
public ActionResult CanDeleteDepartment(int id)
{
return(this.JsonNet(HRBusinessService.CanDeleteDepartment(UserOrganisationId, id)));
}
public ActionResult CompanyBuilding(int companyId)
{
return(this.JsonNet(HRBusinessService.RetrieveCompanyBuilding(UserOrganisationId, companyId)));
}
public ActionResult CanDeleteCompanyBuilding(int companyId, int buildingId)
{
var result = HRBusinessService.CanDeleteCompanyBuilding(UserOrganisationId, companyId, buildingId);
return(this.JsonNet(result));
}
public ActionResult Search(string searchKeyword, Paging paging, List <OrderBy> orderBy)
{
return(this.JsonNet(HRBusinessService.RetrievePersonnelBySearchKeyword(UserOrganisationId, searchKeyword, orderBy, paging)));
}
public ActionResult Edit(PersonnelProfileViewModel personnelViewModel)
{
if (ModelState.IsValid)
{
personnelViewModel.Personnel = HRBusinessService.UpdatePersonnel(UserOrganisationId, personnelViewModel.Personnel);
if (personnelViewModel.ApprovalEntityTypeAssignments != null)
{
foreach (var approvalEntityTypeAssignment in personnelViewModel.ApprovalEntityTypeAssignments)
{
PersonnelApprovalModel personnelApprovalModel = new PersonnelApprovalModel
{
PersonnelId = personnelViewModel.Personnel.PersonnelId,
ApprovalEntityTypeId = approvalEntityTypeAssignment.ApprovalEntityId,
ApprovalModelId = approvalEntityTypeAssignment.ApprovalModelId,
PersonnelApprovalModelId = approvalEntityTypeAssignment.PersonnelApprovalModelId
};
if (personnelApprovalModel.PersonnelApprovalModelId == 0)
{
HRBusinessService.CreatePersonnelApprovalModel(UserOrganisationId, personnelApprovalModel);
}
else if (personnelApprovalModel.ApprovalModelId == 0)
{
HRBusinessService.DeletePersonnelApprovalModel(UserOrganisationId, personnelApprovalModel.PersonnelApprovalModelId);
}
else
{
HRBusinessService.UpdatePersonnelApprovalModel(UserOrganisationId, personnelApprovalModel);
}
}
}
var editUser = UserManager.FindByPersonnelId(personnelViewModel.Personnel.PersonnelId);
editUser.Email = personnelViewModel.Personnel.Email;
var result = UserManager.Update(editUser);
if (result.Succeeded)
{
if (User.IsInRole("User"))
{
return(RedirectToAction("Profile", "Personnel", new { id = personnelViewModel.Personnel.PersonnelId }));
}
else
{
return(RedirectToAction("Index"));
}
}
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error);
}
}
var approvalEntityTypeAssignments = HRBusinessService.ApprovalEntityTypeAssignments(UserOrganisationId, personnelViewModel.Personnel.PersonnelId);
var approvalModels = HRBusinessService.RetrieveApprovalModels(UserOrganisationId);
var viewModel = new PersonnelProfileViewModel
{
Countries = new SelectList(HRBusinessService.RetrieveCountries(UserOrganisationId, null, null).Items, "CountryId", "Name"),
Personnel = personnelViewModel.Personnel,
ApprovalEntityTypeAssignments = approvalEntityTypeAssignments,
ApprovalModels = approvalModels
};
return(View(viewModel));
}
public ActionResult Create(PersonnelProfileViewModel personnelViewModel)
{
try
{
var organisationId = UserOrganisationId;
// check if user with this email already exists for the current organisation
var userExists = UserManager.FindByEmail(personnelViewModel.Personnel.Email);
if (userExists != null)
{
ModelState.AddModelError("", string.Format("An account already exists for the email address {0}", personnelViewModel.Personnel.Email));
}
var modelError = ModelState.Values.Where(e => e.Errors.Count > 0);
if (ModelState.IsValid)
{
personnelViewModel.Personnel = HRBusinessService.CreatePersonnel(organisationId, personnelViewModel.Personnel, personnelViewModel.EmploymentViewModel.Employment, personnelViewModel.EmploymentViewModel.WorkingPatternDays.ToList(), personnelViewModel.EmploymentViewModel.SelectedDepartmentIds, personnelViewModel.EmploymentViewModel.SelectedTeamIds);
var result = CreateUserAndRole(personnelViewModel.Personnel);
if (personnelViewModel.ApprovalEntityTypeAssignments != null)
{
foreach (var approvalEntityTypeAssignment in personnelViewModel.ApprovalEntityTypeAssignments)
{
PersonnelApprovalModel personnelApprovalModel = new PersonnelApprovalModel
{
PersonnelId = personnelViewModel.Personnel.PersonnelId,
ApprovalEntityTypeId = approvalEntityTypeAssignment.ApprovalEntityId,
ApprovalModelId = approvalEntityTypeAssignment.ApprovalModelId,
PersonnelApprovalModelId = approvalEntityTypeAssignment.PersonnelApprovalModelId
};
HRBusinessService.CreatePersonnelApprovalModel(UserOrganisationId, personnelApprovalModel);
}
}
if (result.Succeeded)
{
return(RedirectToAction("Index"));
}
//delete the orphaned personnel & employment records
HRBusinessService.DeletePersonnel(organisationId, personnelViewModel.Personnel.PersonnelId);
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error);
}
}
var jobTitleJobgrades = HRBusinessService.RetrieveJobTitleJobGrade(organisationId);
var defaultSelectedJobTitleJobgrades = jobTitleJobgrades.FirstOrDefault();
var countries = HRBusinessService.RetrieveCountries(organisationId, null, null).Items;
var reportsTo = HRBusinessService.RetrieveReportsToPersonnel(organisationId, 0);
var absencePolices = HRBusinessService.RetrieveAbsencePolices(organisationId);
var publicHolidayPolices = HRBusinessService.RetrievePublicHolidayPolices(organisationId);
var companyBuilding = HRBusinessService.RetrieveEmploymentCompanyBuilding(organisationId);
var employmentTypes = HRBusinessService.RetrieveEmploymentTypes(organisationId);
var approvalEntityTypeAssignments = HRBusinessService.ApprovalEntityTypeAssignments(UserOrganisationId, 0);
var approvalModels = HRBusinessService.RetrieveApprovalModels(UserOrganisationId);
var viewModel = new PersonnelProfileViewModel
{
Countries = new SelectList(countries, "CountryId", "Name"),
Personnel = personnelViewModel.Personnel,
EmploymentViewModel = new EmploymentViewModel
{
ReportsTo = new SelectList(reportsTo, "PersonnelId", "Fullname", personnelViewModel.EmploymentViewModel.Employment.ReportsToPersonnelId),
EmploymentType = new SelectList(employmentTypes, "EmploymentTypeId", "Name", personnelViewModel.EmploymentViewModel.Employment.EmploymentTypeId),
AbsencePolicy = new SelectList(absencePolices, "AbsencePolicyId", "Name"),
PublicHolidayPolicy = new SelectList(publicHolidayPolices, "PublicHolidayPolicyId", "Name"),
JobTitleJobGrades = jobTitleJobgrades,
Employment = personnelViewModel.EmploymentViewModel.Employment,
WorkingPatternDays = personnelViewModel.EmploymentViewModel.WorkingPatternDays,
EmploymentCompanyBuildinglist = companyBuilding,
SelectedDepartmentIds = personnelViewModel.EmploymentViewModel.SelectedDepartmentIds,
SelectedTeamIds = personnelViewModel.EmploymentViewModel.SelectedTeamIds,
SelectedBuildingId = personnelViewModel.EmploymentViewModel.Employment.BuildingId.ToString(),
SelectedCompanyId = personnelViewModel.EmploymentViewModel.Employment.CompanyId.ToString(),
SelectedJobTitleId = defaultSelectedJobTitleJobgrades.JobTitle.JobTitleId.ToString(),
SelectedJobGradeId = defaultSelectedJobTitleJobgrades.JobGrade.JobGradeId.ToString()
},
ApprovalEntityTypeAssignments = approvalEntityTypeAssignments,
ApprovalModels = approvalModels
};
return(View(viewModel));
}
catch (Exception ex)
{
return(this.JsonNet(ex));
}
}
public ActionResult AbsenceRequest(AbsenceRange absenceRange)
{
absenceRange.OrganisationId = UserOrganisationId;
return(this.JsonNet(HRBusinessService.RetrieveAbsenceRequest(UserOrganisationId, absenceRange)));
}
public ActionResult Delete(int id)
{
HRBusinessService.DeleteDepartment(UserOrganisationId, id);
return(RedirectToAction("Index"));
}
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));
}
public ActionResult List(Paging paging, List <OrderBy> orderBy)
{
return(this.JsonNet(HRBusinessService.RetrieveDepartments(UserOrganisationId, orderBy, paging)));
}
public ActionResult DeletePersonnelEmployment(int personnelId, int employmentId)
{
HRBusinessService.DeletePersonnelEmployment(UserOrganisationId, personnelId, employmentId);
return(this.JsonNet(true));
}
public ActionResult ListTeamFilters()
{
return(this.JsonNet(HRBusinessService.RetrieveDepartmentFilters(UserOrganisationId)));
}
public ActionResult AssignAbsencePolicyAbsenceType(int absencePolicyId, int absenceTypeId)
{
return(this.JsonNet(HRBusinessService.CreateAbsencePolicyEntitlement(UserOrganisationId, absencePolicyId, absenceTypeId)));
}
public ActionResult Cancel(int personnelId, int id)
{
HRBusinessService.DeleteAbsence(UserOrganisationId, id);
return(Content(true.ToString()));
}
public ActionResult Delete(int absencePolicyId)
{
HRBusinessService.DeleteAbsencePolicy(UserOrganisationId, absencePolicyId);
return(this.JsonNet(""));
}
public ActionResult Create(int?personnelId, int?id)
{
var organisationId = UserOrganisationId;
if (personnelId == null)
{
personnelId = UserPersonnelId;
}
var employment = HRBusinessService.RetrieveEmployment(organisationId, personnelId.Value, _defaultDate);
var personnelAbsenceEntitlements = HRBusinessService.RetrievePersonnelCurrentAbsenceEntitlements(organisationId, personnelId.Value, employment.EmploymentId);
if (personnelAbsenceEntitlements == null || !personnelAbsenceEntitlements.Any())
{
ModelState.AddModelError("",
"Absence entitlements may not been correctly configured, please contact your HR administrator.");
}
var employmentStartDate = HRBusinessService.RetrievePersonnelEmployments(organisationId, personnelId.Value).Min(e => e.StartDate);
var employmentEndDate = personnelAbsenceEntitlements.Max(e => e.EndDate);
var personnel = HRBusinessService.RetrievePersonnel(organisationId, personnelId.Value);
var absenceTypes = employment.AbsencePolicy.AbsencePolicyEntitlements.Select(item => item.AbsenceType).ToList();
if (id == null)
{
id = absenceTypes.FirstOrDefault()?.AbsenceTypeId ?? 0;
}
var personnelAbsenceEntitlement = personnelAbsenceEntitlements
.FirstOrDefault(p => p.AbsenceTypeId == id.Value &&
p.StartDate <= _defaultDate &&
p.EndDate >= _defaultDate);
if (personnelAbsenceEntitlement == null)
{
personnelAbsenceEntitlement = personnelAbsenceEntitlements
.OrderByDescending(p => p.EndDate)
.FirstOrDefault(p =>
p.StartDate <= _defaultDate &&
p.EndDate >= _defaultDate);
}
var periodDates = HRBusinessService.RetrieveAbsencePolicyAbsencePeriods(organisationId, employment.AbsencePolicyId, null, null);
var periodsBeginDate = periodDates.Items.Min(a => a.AbsencePeriod.StartDate).Date;
var periodsEndDate = periodDates.Items.Max(a => a.AbsencePeriod.EndDate).Date;
var viewModel = new AbsenceViewModel
{
BeginDate = periodsBeginDate,
EndDate = periodsEndDate,
EmploymentBeginDate = employmentStartDate,
EmploymentEndDate = employmentEndDate,
Absence = new AbsenceRange
{
OrganisationId = organisationId,
BeginDateUtc = _defaultDate,
EndDateUtc = _defaultDate,
PersonnelId = personnelId.Value,
},
Period = personnelAbsenceEntitlement.Period,
AbsenceTypes = new SelectList(absenceTypes, "AbsenceTypeId", "Name"),
PersonnelAbsenceEntitlement = personnelAbsenceEntitlement
};
return(View(viewModel));
}
public ActionResult AbsencePeriodsByPersonnel(int personnelId, Paging paging, List <OrderBy> orderBy)
{
return(this.JsonNet(HRBusinessService.RetrieveAbsencePolicyAbsencePeriodsByPersonnel(UserOrganisationId, personnelId)));
}
public ActionResult List(int personnelId, int absencePeriodId)
{
return(this.JsonNet(HRBusinessService.RetrieveAbsences(UserOrganisationId, personnelId, absencePeriodId, User.IsInAnyRoles("Admin"))));
}
public ActionResult CreateAbsencePolicyPeriod(AbsencePolicyPeriod absencePolicyPeriod)
{
return(this.JsonNet(HRBusinessService.CreateAbsencePolicyAbsencePeriod(UserOrganisationId, absencePolicyPeriod)));
}
public ActionResult Periods(int personnelId)
{
return(this.JsonNet(HRBusinessService.RetrievePersonnelAbsencePeriods(UserOrganisationId, personnelId)));
}
public ActionResult UnassignAbsencePeriod(int absencePolicyPeriodId)
{
HRBusinessService.DeleteAbsencePolicyPeriod(UserOrganisationId, absencePolicyPeriodId);
return(this.JsonNet(""));
}
public ActionResult CanDeleteAbsenceType(int id)
{
return(this.JsonNet(HRBusinessService.CanDeleteAbsenceType(UserOrganisationId, id)));
}
