private List <EmployeeSalary> search()
{
List <EmployeeSalary> list = new List <EmployeeSalary>();
connection = new MySqlConnection(connString);
try
{
connection.Open();
command = new MySqlCommand(sql, connection);
dataReader = command.ExecuteReader();
while (dataReader.Read())
{
EmployeeSalary empslr = new EmployeeSalary();
empslr.EmployeeID = dataReader.GetInt32(0);
empslr.Salary = dataReader.GetInt32(1);
empslr.Bonus = dataReader.GetInt32(2);
empslr.Employment_type = dataReader.GetString(3);
list.Add(empslr);
}
dataReader.Close();
command.Dispose();
connection.Close();
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
return(list);
}
public ViewResult GetSalary(string name)
{
EmployeeSalary _employeeSalary = _salaryRepository.GetSalaryByName(name);
var model = _employeeSalary;
return(View(model));
}
/// <summary>
/// Gets employee salary
/// </summary>
/// <returns></returns>
private double GetEmployeesSalaries(EmployeeSalary employee)
{
try
{
double salary = 0;
CalculateSalaryMonthly calculate;;
if (employee.ContractType.ContractTypeName == _configuration.GetSection("SalariesSettings").GetSection("Monthly").Value)
{
calculate = new CalculateSalaryMonthly();
salary = calculate.GetEmployeeSalary(employee);
}
if (employee.ContractType.ContractTypeName == _configuration.GetSection("SalariesSettings").GetSection("Hourly").Value)
{
calculate = new CalculateSalaryHourly();
salary = calculate.GetEmployeeSalary(employee);
}
return(salary);
}
catch (Exception)
{
throw new Exception();
}
}
public void Save(EmployeeSalary employeeSalary)
{
using (var em = EntityManagerFactory.CreateInstance(ds))
{
Save(em, null, employeeSalary);
}
}
/// <summary>
/// Gets an employee with their calculate annual salary from an api list
/// </summary>
/// <param name="apiList">Employees api</param>
/// <returns>An employees with annual salary</returns>
private EmployeeSalary GetEmployee(Api api)
{
try
{
Task <ContractType> contractType = GetContractType(api.ContractTypeName);
EmployeeSalary employee = new EmployeeSalary()
{
Id = api.Id,
Name = api.Name,
ContractType = contractType.Result,
Role = new Role()
{
Id = api.RoleId,
Name = api.RoleName,
Description = api.RoleDescription,
HourlySalary = api.HourlySalary,
MonthlySalary = api.MonthlySalary
},
};
employee.Salary = GetEmployeesSalaries(employee);
return(employee);
}
catch (Exception)
{
throw new Exception();
}
}
public async Task <List <EmployeeSalary> > GetById(int Id)
{
List <EmployeeSalary> respuesta = new List <EmployeeSalary>();
EmployeeSalary employeeSalary = new EmployeeSalary();
var result = await iemployeeRepository.GetAll();
var employee = result.Where(x => x.Id == Id).FirstOrDefault();
if (employee.ContractTypeName == Values.ContractHourly)
{
var employeeHourly = Mapper.Map <Employee, EmployeeHourCalculateDto>(employee);
employeeHourly.CalculateSalary();
employeeSalary = Mapper.Map <EmployeeHourCalculateDto, EmployeeSalary>(employeeHourly);
}
else
{
var employeeMonthly = Mapper.Map <Employee, EmployeeMonthlyCalculateDto>(employee);
employeeMonthly.CalculateSalary();
employeeSalary = Mapper.Map <EmployeeMonthlyCalculateDto, EmployeeSalary>(employeeMonthly);
}
respuesta.Add(employeeSalary);
return(respuesta);
}
public EmployeeSalary GetEmployeeSalaryByEmployeeSalaryHistoryID(int pkid)
{
SqlCommand cmd = new SqlCommand();
cmd.Parameters.Add(_ParmPKID, SqlDbType.Int).Value = pkid;
using (SqlDataReader sdr = SqlHelper.ExecuteReader("GetEmployeeSalaryHistoryByPKID", cmd))
{
while (sdr.Read())
{
EmployeeSalary employeeSalary = new EmployeeSalary((int)sdr[_DBEmployeeId]);
employeeSalary.EmployeeSalaryHistoryList = new List <EmployeeSalaryHistory>();
EmployeeSalaryHistory salaryHistory = new EmployeeSalaryHistory();
salaryHistory.EmployeeAccountSet = new AccountSet((int)sdr[_DBAccountSetID], sdr[_DBAccountSetName].ToString());
salaryHistory.HistoryId = (int)sdr[_DBPKID];
byte[] employeeAccountSetItems = sdr[_DBEmployeeAccountSetItems] as byte[];
if (employeeAccountSetItems != null)
{
salaryHistory.EmployeeAccountSet.Items = DeserializeAccountSetItems(employeeAccountSetItems);
}
salaryHistory.EmployeeSalaryStatus = EmployeeSalaryStatusEnum.GetEmployeeSalaryStatusEnum((int)sdr[_DBStatus]);
salaryHistory.AccountsBackName = sdr[_DBAccountsBackName].ToString();
salaryHistory.VersionNumber = (int)sdr[_DBVersionNumber];
salaryHistory.SalaryDateTime = Convert.ToDateTime(sdr[_DBSalaryDateTime]);
salaryHistory.Description = sdr[_DBDescpriton].ToString();
employeeSalary.EmployeeSalaryHistoryList.Add(salaryHistory);
return(employeeSalary);
}
}
return(null);
}
public ActionResult SendEmployeeEmail(int id)
{
if (id <= 0)
{
return(Json(new ResultModel(string.Format("用户薪资不存在"))));
}
EmployeeSalaryBLL empsBLL = new EmployeeSalaryBLL();
EmployeeBLL empBLL = new EmployeeBLL();
ResultModel result = empsBLL.Get(id);
if (result.ResultStatus != 0)
{
return(Json(result));
}
EmployeeSalary rtnEmployeeSalary = result.ReturnValue as EmployeeSalary;
if (rtnEmployeeSalary == null)
{
return(Json(new ResultModel(string.Format("用户薪资不存在"))));
}
result = empBLL.Get(rtnEmployeeSalary.EmpId);
if (result.ResultStatus != 0)
{
return(Json(result));
}
Employee rtnEmployee = result.ReturnValue as Employee;
if (rtnEmployee == null)
{
return(Json(new ResultModel(string.Format("用户不存在"))));
}
string[] To = { "*****@*****.**" };
string Subject = "工资" + rtnEmployeeSalary.PayDate.ToString("yyyyMMdd");
string Body = rtnEmployee.EmpName + "您好，" + rtnEmployeeSalary.PayDate.ToString("yyyyMMdd") + "工资明细为：";
Body += "<br>应发工资：" + rtnEmployeeSalary.TotalAmount;
Body += "<br>养老保险：" + rtnEmployeeSalary.EmpPensionIns;
Body += "<br>医疗保险：" + rtnEmployeeSalary.EmpMedicalIns;
Body += "<br>失业保险：" + rtnEmployeeSalary.EmpUnempIns;
Body += "<br>工伤保险：" + rtnEmployeeSalary.EmpInjuryIns;
Body += "<br>生育保险：" + rtnEmployeeSalary.EmpBirthIns;
Body += "<br>残疾人保险：" + rtnEmployeeSalary.EmpDisabledIns;
Body += "<br>大病保险：" + rtnEmployeeSalary.EmpIllnessIns;
Body += "<br>取暖费：" + rtnEmployeeSalary.EmpHeatAmount;
Body += "<br>公积金：" + rtnEmployeeSalary.EmpHouseFund;
Body += "<br>补充工伤：" + rtnEmployeeSalary.EmpRepInjuryIns;
Body += "<br>个调税：" + rtnEmployeeSalary.PersonalTax;
Body += "<br>实发工资：" + rtnEmployeeSalary.FinalAmount;
SendMail.Send(To, Subject, Body);
return(Json(result));
}
public EmployeeSalary GetAdjustSalaryHistoryByPKID(int id)
{
SqlCommand cmd = new SqlCommand();
cmd.Parameters.Add(_ParmPKID, SqlDbType.Int).Value = id;
using (SqlDataReader sdr = SqlHelper.ExecuteReader("GetAdjustSalaryHistoryByPKID", cmd))
{
while (sdr.Read())
{
EmployeeSalary iRet = new EmployeeSalary((int)sdr[_DBEmployeeID]);
AdjustSalaryHistory adjustSalaryHistory = new AdjustSalaryHistory();
adjustSalaryHistory.AdjustSalaryHistoryID = id;
adjustSalaryHistory.AccountsBackName = sdr[_DBAccountsBackName].ToString();
adjustSalaryHistory.Description = sdr[_DBDescription].ToString();
adjustSalaryHistory.ChangeDate = (DateTime)sdr[_DBChangeDate];
adjustSalaryHistory.AccountSet = new AccountSet(0, sdr[_DBAccountSetName].ToString());
adjustSalaryHistory.AccountSet.Items = DeserializeAccountSetItems(sdr);
adjustSalaryHistory.AccountSet.Description = sdr[_DBDescription].ToString();
iRet.AdjustSalaryHistoryList = new List <AdjustSalaryHistory>();
iRet.AdjustSalaryHistoryList.Add(adjustSalaryHistory);
return(iRet);
}
}
return(null);
}
public ActionResult Create([Bind(Include = "Id,EmployeeId,Salary,Months,Date,Status,SessionId")] EmployeeSalary employeeSalary)
{
var month = Request.Form["MonthName"];
int counter = db.EmployeeSalaries.Where(x => x.EmployeeId == employeeSalary.EmployeeId && x.Months == month).Count();
if (counter == 0)
{
if (ModelState.IsValid)
{
string e_salary = Request.Form["salary"];
var name = Request.Form["MonthName"];
employeeSalary.Months = name;
employeeSalary.Status = "Pending";
db.EmployeeSalaries.Add(employeeSalary);
db.SaveChanges();
Ledger ledger_exp = db.Ledgers.Where(x => x.Name == "Employee Clearing").FirstOrDefault();////Expence
ledger_exp.CurrentBalance += Convert.ToDecimal(e_salary);
db.SaveChanges();
Ledger ledger_lib = db.Ledgers.Where(x => x.Name == "Employee Salary").FirstOrDefault();////Liability
ledger_lib.CurrentBalance += Convert.ToDecimal(e_salary);
db.SaveChanges();
return(RedirectToAction("Index"));
}
}
ViewBag.EmployeeId = new SelectList(db.AspNetEmployees, "Id", "Name", employeeSalary.EmployeeId);
return(View(employeeSalary));
}
private void BindEmployeeSetByEmployeeID(int employeeID)
{
try
{
_ItsView.ResultMessage = string.Empty;
EmployeeSalary employeeSalary;
EmployeeSalary temp = _IEmployeeAccountSetFacade.GetEmployeeAccountSetByEmployeeID(employeeID);
if (temp != null)
{
employeeSalary = temp;
_ItsView.Description = employeeSalary.AccountSet.Description;
}
else
{
employeeSalary = new EmployeeSalary(employeeID);
employeeSalary.AccountSet = _IAccountSetFacade.GetWholeAccountSetByPKID(_ItsView.AccountSetID);
}
employeeSalary.Employee = _IEmployeeFacade.GetEmployeeBasicInfoByAccountID(employeeID);
_ItsView.EmployeeSalary = employeeSalary;
}
catch (Exception ex)
{
_ItsView.ResultMessage = "<span class='fontred'>" + ex.Message + "</span>";
}
}
public ActionResult Edit(decimal id, EmployeeSalary employeeSalary)
{
try
{
if (ModelState.IsValid)
{
EmployeeSalary obj = EmployeeSalary.Find(id);
if (obj != null)
{
obj = employeeSalary;
EmployeeSalary.Update(obj);
ViewBag.Message = "Employee Salary Updated Successfully";
}
return(RedirectToAction("Index"));
}
else
{
return(View());
}
}
catch (Exception ex)
{
return(View());
}
}
public ActionResult Index(FormCollection form)
{
Output.Write("Employee Salary Id is: " + BonusesController.EmployeeSalaryId);
EmployeeSalary employeeSalary = employeeSalaryService.Get(BonusesController.EmployeeSalaryId);
Bonus mainBonus = mainBonusService.Get(employeeSalary.BonusId);
int bonusAmount = Int32.Parse(form["BonusAmount"]);
Bonuses bonus = new Bonuses
{
BonusId = mainBonus.BonusId,
BonusValue = bonusAmount,
BonusDescription = form["BonusReason"]
};
Output.Write("Employee Salary Id is: " + employeeSalary.EmployeeSalaryId);
Output.Write("Bonus id is: " + mainBonus.BonusId);
Output.Write("Bonus amount is: " + bonusAmount);
mainBonus.BonusValue += bonusAmount;
mainBonusService.Update(mainBonus, mainBonus.BonusId);
bonusComponentService.Insert(bonus);
//new ServiceFactory().Create<Employee>().GetAll();
//ServiceFactory.GetCommonViewService().AssignBonusToEmployee(bonus, Int32.Parse(form["EmpId"]));
return(RedirectToAction("EmployeeDisplay", "EmployeeEvaluations"));
}
public async Task <List <EmployeeSalary> > GetById(int Id)
{
try
{
List <EmployeeSalary> respuesta = new List <EmployeeSalary>();
EmployeeSalary employeeSalary = new EmployeeSalary();
var result = await _EmployeeLogic.GetAll();
var employee = result.Where(x => x.Id == Id).FirstOrDefault();
if (employee.ContractTypeName == ConstantValues.ContractHourly)
{
var employeeHourly = Mapper.Map <Employee, HourlyEmployeeDTO>(employee);
employeeHourly.CalculateSalary();
employeeSalary = Mapper.Map <HourlyEmployeeDTO, EmployeeSalary>(employeeHourly);
}
else
{
var employeeMonthly = Mapper.Map <Employee, MonthlyEmployeeDTO>(employee);
employeeMonthly.CalculateSalary();
employeeSalary = Mapper.Map <MonthlyEmployeeDTO, EmployeeSalary>(employeeMonthly);
}
respuesta.Add(employeeSalary);
return(respuesta);
}
catch (Exception)
{
throw;
}
}
public async Task <ServiceResponse <object> > AddEmployeeSalary(SalaryForAddDto model)
{
var ToAdd = new EmployeeSalary
{
EmployeeId = model.EmployeeId,
Amount = Convert.ToDouble(model.Amount),
Posted = false,
CreatedDate = DateTime.UtcNow,
CreatedById = _LoggedIn_UserID,
SchoolBranchId = _LoggedIn_BranchID,
};
await _context.EmployeeSalaries.AddAsync(ToAdd);
await _context.SaveChangesAsync();
var ToAdd2 = new EmployeeSalaryTransaction
{
EmployeeId = model.EmployeeId,
Amount = Convert.ToDouble(model.Amount),
Posted = ToAdd.Posted,
UpdatedDate = DateTime.UtcNow,
UpdatedById = _LoggedIn_UserID,
SchoolBranchId = _LoggedIn_BranchID,
};
await _context.EmployeeSalaryTransactions.AddAsync(ToAdd2);
await _context.SaveChangesAsync();
_serviceResponse.Message = CustomMessage.Added;
_serviceResponse.Success = true;
return(_serviceResponse);
}
protected override void Validation()
{
_EmployeeSalaryList = new List <EmployeeSalary>();
//获取所有员工
_EmployeeList = _GetEmployee.GetEmployeeWithCurrentMonthDimissionEmployee(_SalaryTime, _CompanyId,
_DepartmentID);
foreach (Employee employee in _EmployeeList)
{
//获取员工当月工资
EmployeeSalaryHistory salaryHistory =
_DalEmployeeSalary.GetEmployeeSalaryHistoryByEmployeeIdAndDateTime(employee.Account.Id, _SalaryTime);
//判断当月工资是否存在
if (salaryHistory == null)
{
throw new ApplicationException(employee.Account.Name +
BllUtility.GetResourceMessage(
BllExceptionConst._Employee_Salary_NotExist));
}
//当月工资是否已封帐
if (Equals(salaryHistory.EmployeeSalaryStatus, EmployeeSalaryStatusEnum.AccountClosed))
{
throw new ApplicationException(employee.Account.Name +
BllUtility.GetResourceMessage(
BllExceptionConst._Employee_Salary_Closed));
}
var employeeSalary = new EmployeeSalary(employee.Account.Id);
employeeSalary.Employee = employee;
employeeSalary.EmployeeSalaryHistoryList = new List <EmployeeSalaryHistory>();
employeeSalary.EmployeeSalaryHistoryList.Add(salaryHistory);
_EmployeeSalaryList.Add(employeeSalary);
}
}
//кнопка 'Добавить'
private void Added_Click(object sender, EventArgs e)
{
try
{
EmployeeSalary employee = new EmployeeSalary();
if (lastNameText.Text != "" && nameText.Text != "" && secondNameText.Text != "" &&
employeeWageCategoryText.Text != "" && scopeOfWorkText.Text != "" && unitCostText.Text != "")
{
employee.lastName = lastNameText.Text;
employee.name = nameText.Text;
employee.secondName = secondNameText.Text;
employee.EmployeeWageCategory = double.Parse(employeeWageCategoryText.Text);
employee.ScopeOfWork = double.Parse(scopeOfWorkText.Text);
employee.UnitCost = double.Parse(unitCostText.Text);
}
else
{
MessageBox.Show("Вы заполнили не все поля", "Error");
}
}catch (FormatException ex)
{
MessageBox.Show(ex.Message, "Строка имела неверный формат");
//Console.WriteLine($"Строка имела неверный формат: {0}", ex.Message);
}catch (ArgumentException ex)
{
MessageBox.Show(ex.Message, "Некорректные данные");
//Console.WriteLine($"Некорректные данные: {0}", ex.Message);
}
}
public static EmployeeSalary GetEmployeeSalary(string sp_query, DynamicParameters param)
{
RepList <EmployeeSalary> repList = new RepList <EmployeeSalary>();
EmployeeSalary employeeSalary = repList.returnClass_SP(sp_query, param);
return(employeeSalary);
}
protected override void Validation()
{
_EmployeeSalaryList = new List <EmployeeSalary>();
//获取所有员工
_EmployeeList = _GetEmployee.GetEmployeeWithCurrentMonthDimissionEmployee(_SalaryTime, _CompanyId, _DepartmentId);
foreach (Employee employee in _EmployeeList)
{
EmployeeSalaryHistory salaryHistory =
_DalEmployeeSalary.GetEmployeeSalaryHistoryByEmployeeIdAndDateTime(employee.Account.Id, _SalaryTime);
//判断当月工资是否存在
if (salaryHistory == null)
{
BllUtility.ThrowException(BllExceptionConst._Employee_Salary_NotExist);
}
//判断当月工资状态是否没有封帐
else if (salaryHistory.EmployeeSalaryStatus != EmployeeSalaryStatusEnum.AccountClosed)
{
BllUtility.ThrowException(BllExceptionConst._Employee_Salary_Not_Closed);
}
var employeeSalary = new EmployeeSalary(employee.Account.Id);
employeeSalary.Employee = employee;
employeeSalary.EmployeeSalaryHistoryList = new List <EmployeeSalaryHistory>();
employeeSalary.EmployeeSalaryHistoryList.Add(salaryHistory);
_EmployeeSalaryList.Add(employeeSalary);
}
}
public async Task <ActionResult <Employee> > PostEmployee(EmployeeSalary employeeSalary)
{
using (IDbContextTransaction transaction = _context.Database.BeginTransaction())
{
try
{
//Save Employee
_context.Employees.Add(employeeSalary.Employee);
await _context.SaveChangesAsync();
//Save Salary
employeeSalary.Salary.IdEmp = employeeSalary.Employee.Id;
_context.Salaries.Add(employeeSalary.Salary);
await _context.SaveChangesAsync();
transaction.Commit();
}
catch (Exception)
{
transaction.Rollback();
}
}
return(CreatedAtAction("GetEmployee", new { id = employeeSalary.Employee.Id }, employeeSalary.Employee));
}
public static Employee GetFullEmployee(EmployeeSalary pEmployee)
{
Employee employee = null;
switch (pEmployee.ContractTypeName)
{
case "HourlySalaryEmployee":
employee = new HourlyContractEmployee()
{
HourlySalary = pEmployee.HourlySalary
};
break;
case "MonthlySalaryEmployee":
employee = new MonthlyContractEmployee()
{
MonthlySalary = pEmployee.MonthlySalary
};
break;
}
employee.Id = pEmployee.Id;
employee.ContractTypeName = pEmployee.ContractTypeName;
employee.Name = pEmployee.Name;
employee.RoleDescription = pEmployee.RoleDescription ?? string.Empty;
employee.RoleName = pEmployee.RoleName;
employee.RoleId = pEmployee.RoleId;
return(employee);
}
public JsonResult DeleteEmployeeSalary(EmployeeSalary employeeSalary)
{
var isSuccess = true;
var message = string.Empty;
const string url = "/EmployeeSalary/Index";
permission = (RoleSubModuleItem)cacheProvider.Get(cacheKey) ?? roleSubModuleItemService.GetRoleSubModuleItemBySubModuleIdandRole(url,
Helpers.UserSession.GetUserFromSession().RoleId);
if (permission.DeleteOperation == true)
{
isSuccess = this.employeeSalaryService.DeleteEmployeeSalary(employeeSalary.Id);
if (isSuccess)
{
message = Resources.ResourceEmployeeSalary.MsgEmployeeSalaryDeleteSuccessful;
}
else
{
message = Resources.ResourceEmployeeSalary.MsgEmployeeSalaryDeleteFailed;
}
}
else
{
message = Resources.ResourceCommon.MsgNoPermissionToDelete;
}
return(Json(new
{
isSuccess = isSuccess,
message = message
}, JsonRequestBehavior.AllowGet));
}
public ActionResult Create(FormCollection fr)
{
EmployeeSalary obj = new EmployeeSalary();
obj.Es_Date = Convert.ToDateTime(fr["Es_Date"]);
obj.Es_Salary = Convert.ToDecimal(fr["Es_Salary"]);
obj.Es_Emp_Id = Convert.ToInt32(fr["Es_Emp_Id"]);
int CheckCount = obj.check(obj.Es_Emp_Id, obj.Es_Date);
if (CheckCount == 0)
{
int Result = obj.Create(obj);
if (Result > 0)
{
return(RedirectToAction("List"));
}
else
{
ViewData["Error"] = "Something was wrong !!";
ViewData["Employee"] = Constants.BindActiveEmployee();
return(View(obj));
}
}
else
{
ViewData["Error"] = "Enter Duplicate Record !!";
ViewData["Employee"] = Constants.BindActiveEmployee();
return(View(obj));
}
}
public ActionResult Save(EmployeeSalaryViewModel obj)
{
// IEnumerable<EmployeeSalaryViewModel> en = customerDueFeesList;
// en = jss.Deserialize<IEnumerable<EmployeeSalaryViewModel>>(obj.EmployeeSalaryViewModelList);
List <EmployeeSalaryViewModel> employeeSalaryViewModelList;
JavaScriptSerializer jss = new JavaScriptSerializer();
EmployeeSalary employeeSalary = new EmployeeSalary();
employeeSalaryViewModelList = jss.Deserialize <List <EmployeeSalaryViewModel> >(obj.SalaryList);
foreach (var employeeSalaryViewModel in employeeSalaryViewModelList)
{
if (employeeSalaryViewModel.FullName == null)
{
//for the last row of table
}
else
{
employeeSalary.FullName = employeeSalaryViewModel.FullName;
employeeSalary.WorkHours = employeeSalaryViewModel.WorkHours;
employeeSalary.RatePerHour = employeeSalaryViewModel.RatePerHour;
employeeSalary.OverTimeHours = employeeSalaryViewModel.OverTimeHours;
employeeSalary.RatePerHourOvertime = employeeSalaryViewModel.RatePerHourOvertime;
employeeSalary.Date = employeeSalaryViewModel.Date;
employeeSalary.SalaryId = employeeSalaryViewModel.SalaryId;
_dbContext.EmployeeSalaries.Add(employeeSalary);
_dbContext.SaveChanges();
}
}
return(Json(new { success = true }));
}
private async Task UpdateSalaryForEmployee(Guid employeeId, decimal newSalary, decimal oldSalary, DateTime?startDate, DateTime?endDate, string modifiedBy,
EmployeeSalary empSalary)
{
if (empSalary != null)
{
_logger.LogInformation(
$"{nameof(EmployeeSalaryChangedIntegrationEventHandler)} - Updating employee salary: {empSalary.EmployeeId}",
empSalary.EmployeeId);
if (empSalary.Salary != oldSalary)
{
empSalary.Salary = newSalary;
empSalary.StartDate = startDate;
empSalary.EndDate = endDate;
empSalary.ModifiedOn = DateTime.Now;
empSalary.ModifiedBy = modifiedBy;
await _empSalaryRepository.UpdateEmployeeSalaryAsync(empSalary);
}
}
else
{
await _empSalaryRepository.AddEmployeeSalaryAsync(new EmployeeSalary()
{
EmployeeId = employeeId,
Salary = newSalary,
StartDate = startDate,
EndDate = endDate,
CreatedBy = modifiedBy,
CreatedOn = DateTime.Now,
ModifiedBy = modifiedBy,
ModifiedOn = DateTime.Now
});
}
}
public ActionResult Delete(int id, FormCollection collection)
{
try
{
// TODO: Add delete logic here
using (DbModel dbModel = new DbModel())
{
List <EmployeeSalary> lstemployeeSalary = dbModel.EmployeeSalaries.Where(x => x.EmpId == id).ToList();
if (lstemployeeSalary?.Count > 0)
{
foreach (var item in lstemployeeSalary)
{
EmployeeSalary employeeSalary = dbModel.EmployeeSalaries.Where(x => x.Id == item.Id).FirstOrDefault();
dbModel.EmployeeSalaries.Remove(employeeSalary);
dbModel.SaveChanges();
}
}
Employee employee = dbModel.Employees.Where(x => x.Id == id).FirstOrDefault();
dbModel.Employees.Remove(employee);
dbModel.SaveChanges();
}
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
public ActionResult DeleteConfirmed(int id)
{
EmployeeSalary employeeSalary = db.EmployeeSalary.Find(id);
db.EmployeeSalary.Remove(employeeSalary);
db.SaveChanges();
return(RedirectToAction("Index"));
}
// POST api/employeesalary
public EmployeeSalary Post(EmployeeSalary emplSlr)
{
if (emplslrService.Insert(emplSlr))
{
return(emplSlr);
}
return(null);
}
public IActionResult Search(EmployeeSalary employeeSalary)
{
if (employeeSalary.EmployeeName != null)
{
return(RedirectToAction("GetSalary", new { name = employeeSalary.EmployeeName }));
}
return(RedirectToAction("search"));
}
static void Main()
{
EmployeeSalary e1 = new EmployeeSalary("Shayan Saha", 39767);
e1.CalculateNetPay();
e1.Display();
Console.ReadKey();
}
private void btnSubmit_Click(object sender, EventArgs e)
{
lblResult.Text = string.Empty;
if(!ValidateInput())
{
var employeeSalary = new EmployeeSalary();
employeeSalary.FirstName = txtFirstName.Text;
employeeSalary.LastName = txtLastName.Text;
employeeSalary.Salary = Convert.ToDecimal(txtSalary.Text);
employeeSalary.EmailAddress = txtEmail.Text;
employeeSalary.SupervisorId = employeeId;
service.InsertEmployee(employeeSalary);
EmployeeInserted();
}
}
