private void SetupYearlyPay(out Employee employee, out EmployeePay expectedYearlyPay)
{
employee = new Employee
{
FirstName = "Nathan",
LastName = "LaVeck",
Dependents = new List <Dependent>()
{
new Dependent
{
Relation = DependentRelation.Spouse,
FirstName = "Alyssa",
LastName = "Cantrell"
}
}
};
expectedYearlyPay = new EmployeePay
{
GrossIncome = 52000M,
BenefitsDiscount = sut.CalculateMemberDiscount(employee.Dependents[0]), // Spouse gets a discount
BenefitsPremium = employee.MemberYearlyBenefitsCost + employee.Dependents[0].MemberYearlyBenefitsCost,
};
expectedYearlyPay.BenefitsSubtotal = expectedYearlyPay.BenefitsPremium - expectedYearlyPay.BenefitsDiscount;
expectedYearlyPay.TaxableIncome = expectedYearlyPay.GrossIncome - expectedYearlyPay.BenefitsSubtotal;
}
private void btnAddPart_Click(object sender, EventArgs e)
{
if (isValidPartPayroll())
{
try
{ EmployeePay empPayt = new EmployeePay();
empPayt.EmployeeID = (long)Convert.ToDouble(DBMethod.GetSelectedItemID(cmbPartEmp));
empPayt.ThisPaymentMethod = DBMethod.GetSelectedItemID(cmbPaymentMethod);
empPayt.FromDate = dtpFormDate.Value;
empPayt.ToDate = dtpToDate.Value;
empPayt.Amount = Convert.ToDouble(lblPartAmount.Text.Trim());
empPayt.PaymentDate = DateTime.Today.Date;
DBConnector conn = new DBConnector(Classes.DBMethod.GetConnectionString());
RosieEntity.Connector = conn;
empPayt.Create();
FillPayGrid(sqlText);
updateHourIsPaid("1");
clearData(); }
catch (Exception ex)
{
//MessageBox.Show(ex.Message);
MessageBox.Show("You can't add this payroll record, The Employee's payroll has been registered ", "ERROR", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
/*
* Updates the employee with the calculated pay annually and per paycheck
*/
public void CalculatePay(Employee employee)
{
if (employee == null)
{
throw new ArgumentNullException("Missing required arguement employee");
}
if (employee.Dependents == null)
{
throw new NullReferenceException("Dependents must be populated before calling calculate pay");
}
var annualPay = new EmployeePay()
{
Term = Frequency.Annual,
GrossIncome = EmployeePay.GROSS_PER_PAYCHECK * EmployeePay.NUMBER_OF_PAYCHECKS,
BenefitsPremium = employee.Dependents.Aggregate(employee.MemberYearlyBenefitsCost, (total, dependent) => total + dependent.MemberYearlyBenefitsCost),
BenefitsDiscount = employee.Dependents.Aggregate(CalculateMemberDiscount(employee), (total, dependent) => total + CalculateMemberDiscount(dependent)),
};
annualPay.BenefitsSubtotal = annualPay.BenefitsPremium - annualPay.BenefitsDiscount;
annualPay.TaxableIncome = annualPay.GrossIncome - annualPay.BenefitsSubtotal;
var paycheckPay = new EmployeePay()
{
Term = Frequency.Paycheck,
GrossIncome = EmployeePay.GROSS_PER_PAYCHECK,
BenefitsPremium = decimal.Round(annualPay.BenefitsPremium / EmployeePay.NUMBER_OF_PAYCHECKS, 2, MidpointRounding.AwayFromZero),
BenefitsDiscount = decimal.Round(annualPay.BenefitsDiscount / EmployeePay.NUMBER_OF_PAYCHECKS, 2, MidpointRounding.AwayFromZero),
};
paycheckPay.BenefitsSubtotal = paycheckPay.BenefitsPremium - paycheckPay.BenefitsDiscount;
paycheckPay.TaxableIncome = paycheckPay.GrossIncome - paycheckPay.BenefitsSubtotal;
employee.AnnualPay = annualPay;
employee.PaycheckPay = paycheckPay;
}
public async Task <IActionResult> Edit(string id, EmployeeManagement employeeManagement)
{
if (id != employeeManagement.Employee.Id)
{
return(NotFound());
}
if (employeeManagement.Employee.SupervisorId == id || employeeManagement.Employee.ApproverId == id)
{
ViewBag.ErrorMessage = "Supervisor and Approver can't be themselves";
return(await Edit(id));
}
if (ModelState.IsValid)
{
try
{
var something = _userManager.GetUserId(this.User);
if (id == _userManager.GetUserId(this.User) && employeeManagement.Employee.Title == Employee.ADMIN)
{
ViewBag.ErrorMessage = "You cannot assign yourself to admin";
return(await Edit(id));
}
var oldEmployee = await _context.Employees.FindAsync(id);
if (oldEmployee != null)
{
var oldApprover = await _context.Employees.FindAsync(oldEmployee.ApproverId);
if (oldApprover != null)
{
await _userManager.RemoveFromRoleAsync(oldApprover, ApplicationRole.TA);
}
var oldSupervisor = await _context.Employees.FindAsync(oldEmployee.SupervisorId);
if (oldSupervisor != null)
{
await _userManager.RemoveFromRoleAsync(oldSupervisor, ApplicationRole.LM);
}
if (oldEmployee.Title == Employee.HR_MANAGER)
{
await _userManager.RemoveFromRoleAsync(oldEmployee, ApplicationRole.HR);
}
if (oldEmployee.Title == Employee.ADMIN)
{
await _userManager.RemoveFromRoleAsync(oldEmployee, ApplicationRole.AD);
}
}
var employeeToBeEdited = await _userManager.FindByIdAsync(id);
employeeToBeEdited.FirstName = employeeManagement.Employee.FirstName;
employeeToBeEdited.LastName = employeeManagement.Employee.LastName;
employeeToBeEdited.Title = employeeManagement.Employee.Title;
employeeToBeEdited.FlexTime = employeeManagement.Employee.FlexTime;
employeeToBeEdited.VacationTime = employeeManagement.Employee.VacationTime;
employeeToBeEdited.Status = employeeManagement.Employee.Status;
employeeToBeEdited.ApproverId = employeeManagement.Employee.ApproverId;
employeeToBeEdited.SupervisorId = employeeManagement.Employee.SupervisorId;
employeeToBeEdited.UserName = employeeManagement.Employee.Email;
employeeToBeEdited.Email = employeeManagement.Employee.Email;
employeeToBeEdited.PhoneNumber = employeeManagement.Employee.PhoneNumber;
if (!string.IsNullOrEmpty(employeeManagement.passPhrase))
{
var datetime = DateTime.Now;
var newSignature = new Signature
{
HashedSignature = Utility.HashEncrypt(employeeManagement.passPhrase + datetime),
CreatedTime = datetime,
Status = Signature.VALID,
EmployeeId = id
};
var oldSig = _context.Signatures
.Where(s => s.EmployeeId == id)
.FirstOrDefault();
if (oldSig == null)
{
_context.Signatures.Add(newSignature);
}
else
{
oldSig.CreatedTime = newSignature.CreatedTime;
oldSig.HashedSignature = newSignature.HashedSignature;
_context.Signatures.Update(oldSig);
}
await _context.SaveChangesAsync();
}
await _userManager.UpdateAsync(employeeToBeEdited);
var employeePayToBeDisabled = _context.EmployeePays.Find(employeeManagement.EmployeePay.EmployeePayId);
employeePayToBeDisabled.Status = EmployeePay.INVALID;
_context.Update(employeePayToBeDisabled);
await _context.SaveChangesAsync();
var newEmployeePay = new EmployeePay
{
AssignedDate = DateTime.Now,
Status = EmployeePay.VALID,
EmployeeId = employeeToBeEdited.Id,
PayGradeId = employeeManagement.EmployeePay.PayGradeId
};
_context.Add(newEmployeePay);
await _context.SaveChangesAsync();
var approver = _context.Employees.Find(employeeManagement.Employee.ApproverId);
await _userManager.AddToRoleAsync(approver, ApplicationRole.TA);
var supervisor = _context.Employees.Find(employeeManagement.Employee.SupervisorId);
await _userManager.AddToRoleAsync(supervisor, ApplicationRole.LM);
if (employeeManagement.Employee.Title == Employee.HR_MANAGER)
{
await _userManager.AddToRoleAsync(employeeToBeEdited, ApplicationRole.HR);
}
if (employeeManagement.Employee.Title == Employee.ADMIN)
{
await _userManager.AddToRoleAsync(employeeToBeEdited, ApplicationRole.AD);
}
}
catch (DbUpdateConcurrencyException)
{
if (!EmployeeExists(employeeManagement.Employee.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(employeeManagement));
}
