private async Task <SalaryHistory> PrepareSalaryHistory(SalaryServiceModel model)
{
var salaryHistoryRepo = _unitOfWork.GetRepository <SalaryHistory>();
var lastChanged = (await salaryHistoryRepo.GetAsync(x => x.SalaryId == model.Id, x => x.OrderBy(x => x.DateChanged)))
.LastOrDefault();
DateTime fromDate;
if (lastChanged == null)
{
fromDate = model.Employee.HiredDate;
}
else
{
fromDate = lastChanged.ToDate;
}
var salaryHistory = new SalaryHistory
{
DateChanged = DateTime.UtcNow,
Amount = model.Amount,
FromDate = fromDate,
ToDate = DateTime.UtcNow,
Employee = _mapper.Map <Employee>(model.Employee),
SalaryId = model.Id
};
return(salaryHistory);
}
public async Task <bool> UpdateEmployeeSalary(SalaryServiceModel model)
{
try
{
_unitOfWork.BeginTransaction();
var updateModel = _mapper.Map <Salary>(model);
var historyRepo = _unitOfWork.GetRepository <SalaryHistory>();
var salaryHistory = await PrepareSalaryHistory(model);
await _unitOfWork.GetRepository <Salary>().UpdateAsync(updateModel);
await historyRepo.AddItemAsync(salaryHistory);
await _unitOfWork.CommitAsync();
return(true);
}
catch
{
await _unitOfWork.RollbackAsync();
throw;
}
}
public async Task <IActionResult> ChangeJob(UpdateEmployeeJobViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var salId = (await _managerService.GetEmployeeSalary(model.EmployeeEmail)).Id;
var salaryUpdateModel = new SalaryServiceModel
{
Amount = model.Amount,
Currency = await _nomenclatureService.GetCurrency(model.CurrencyId),
SalaryType = await _nomenclatureService.GetSalaryType(model.SalaryTypeId),
Employee = await _accountManageService.GetEmployeeByEmailAsync(model.EmployeeEmail),
Id = salId
};
var jobModel = await _adminService.GetJobById(model.JobId);
await _managerService.UpdateEmployeeJob(jobModel, salaryUpdateModel);
StatusMessage = $"Successfuly updated job for employee with email {model.EmployeeEmail}";
return(RedirectToAction(nameof(ChangeJob), routeValues: new { email = model.EmployeeEmail }));
}
public async Task <bool> UpdateEmployeeJob(JobServiceModel job, SalaryServiceModel model)
{
try
{
_unitOfWork.BeginTransaction();
var jobModel = _mapper.Map <Job>(job);
var updateModel = _mapper.Map <Salary>(model);
var salaryHistoryRepo = _unitOfWork.GetRepository <SalaryHistory>();
var employeeRepo = _unitOfWork.GetRepository <Employee>();
var employee = employeeRepo.GetById(updateModel.Employee.Id);
employee.Job = jobModel;
var salaryHistory = await PrepareSalaryHistory(model);
var jobHistory = new JobHistory
{
DateChanged = salaryHistory.DateChanged,
EmployeeId = employee.Id,
FromDate = salaryHistory.FromDate,
ToDate = salaryHistory.ToDate,
Job = jobModel,
SalaryHistoryId = salaryHistory.SalaryId
};
await _unitOfWork.GetRepository <Salary>().UpdateAsync(updateModel);
await salaryHistoryRepo.AddItemAsync(salaryHistory);
await employeeRepo.UpdateAsync(employee);
await _unitOfWork.GetRepository <JobHistory>().AddItemAsync(jobHistory);
await _unitOfWork.CommitAsync();
return(true);
}
catch
{
await _unitOfWork.RollbackAsync();
throw;
}
}
