//Business Rule: 12 Hours Validation-An employee can be assigned multiple tasks but cannot work more than 12 hours a day
private async Task <bool> IsEmployeeAvailable(EmployeeTasksViewModel employeeTasksViewModel, bool isEmployeeHaveCapacity)
{
var todaysDateandTime = DateTime.Now;
var currentDate = todaysDateandTime.Date;
var employeeCapacity = await this.employeeTaskService.GetEmpHourCapacityOfTheDate(employeeTasksViewModel.EmployeeId, currentDate, null);
var assginedtaskDuration = await this.workItemService.GetWorkItemById(employeeTasksViewModel.TaskId);
int totalNoOfHoursWorked = 0;
int empCapacity = 0;
//Calculating the Employee Salary
foreach (var item in employeeCapacity)
{
totalNoOfHoursWorked += item.TotalNoOfHours;
}
empCapacity = 12 - totalNoOfHoursWorked;
if ((employeeTasksViewModel.TotalNoOfHours > empCapacity) || (assginedtaskDuration.NoOfHours > empCapacity))
{
isEmployeeHaveCapacity = false;
}
return(isEmployeeHaveCapacity);
}
public async Task <ActionResult> Details(int id)
{
_logger.LogInformation("Loading Employee Task to View");
EmployeeTasksViewModel employeeTasksViewModel = await GetEmployeeTaskDataToViewModel(id);
return(View(employeeTasksViewModel));
}
public async Task <ActionResult> Edit(EmployeeTasksViewModel employeeTasksViewModel)
{
bool isEmployeeHaveCapacity = true;
isEmployeeHaveCapacity = await IsEmployeeAvailable(employeeTasksViewModel, isEmployeeHaveCapacity);
//checking model state
if (ModelState.IsValid)
{
if (isEmployeeHaveCapacity)
{
await GetCurrentRatePerHour(employeeTasksViewModel);
var emp = await this.employeeTaskService.UpdateEmployeeTask(_objectMapper.EmployeeTasksViewModelToEmployeeTasks(employeeTasksViewModel));
return(RedirectToAction("Index"));
}
else
{
ModelState.AddModelError("TotalNoOfHours", "Employee doesnt have capacity to Assgin this task");
}
}
EmployeeTasksViewModel employeeTaskViewModel = await GetEmployeeTaskDataToViewModel(employeeTasksViewModel.EmployeeTaskId);
await LoadEmployeesAndTasks(employeeTaskViewModel);
return(View(employeeTaskViewModel));
}
public async Task <IActionResult> Create()
{
EmployeeTasksViewModel employeeTasksViewModel = new EmployeeTasksViewModel();
await LoadEmployeesAndTasks(employeeTasksViewModel);
return(View(employeeTasksViewModel));
}
//Gets Data for Specific Employee Task
private async Task <EmployeeTasksViewModel> GetEmployeeTaskDataToViewModel(int id)
{
var dto = await this.employeeTaskService.GetEmployeeTaskById(id);
EmployeeTasksViewModel employeeTasksViewModel = _objectMapper.EmployeeTaskToEmployeeTasksViewModel(dto);
return(employeeTasksViewModel);
}
public async Task <ActionResult> Edit(int id)
{
_logger.LogInformation("Loading Employee Task to Edit");
EmployeeTasksViewModel employeeTasksViewModel = await GetEmployeeTaskDataToViewModel(id);
await LoadEmployeesAndTasks(employeeTasksViewModel);
return(View(employeeTasksViewModel));
}
//Business Rule: "Changing the hourly rate or changing the casual employee role should not affect previously
//captured hours" i.e reason we getting the rate perhour from the Roles table and Saving in EmployeeTask tabele
private async Task GetCurrentRatePerHour(EmployeeTasksViewModel employeeTasksViewModel)
{
var dtemployeeList = await this.employeeService.GetEmployeeById(employeeTasksViewModel.EmployeeId);
var dtRoleList = await this.rolesService.GetRoleById(dtemployeeList.RoleId);
employeeTasksViewModel.CurrentDate = DateTime.Now;
employeeTasksViewModel.PayPerTask = dtRoleList.RatePerhour;
}
//Get List of All Employees and Tasks(work items) assigns to View Model object
private async Task LoadEmployeesAndTasks(EmployeeTasksViewModel employeeTasksViewModel)
{
var employeeList = await this.employeeService.GetEmployees();
var workItemList = await this.workItemService.GetWorkItems();
employeeTasksViewModel.Employees = employeeList.OrderBy(x => x.FirstName);
employeeTasksViewModel.WorkItems = workItemList.OrderBy(x => x.TaskId);
}
private async Task <EmployeeTasksViewModel> LoadEmployeeDetails()
{
EmployeeTasksViewModel empTaskView = new EmployeeTasksViewModel();
var employeeList = await this.employeeService.GetEmployees();
var workItemList = await this.workItemService.GetWorkItems();
empTaskView.Employees = employeeList;
empTaskView.WorkItems = workItemList;
return(empTaskView);
}
public EmployeeTask EmployeeTasksViewModelToEmployeeTasks(EmployeeTasksViewModel employeeTasksViewModel)
{
return(new EmployeeTask()
{
EmployeeTaskId = employeeTasksViewModel.EmployeeTaskId,
EmployeeId = employeeTasksViewModel.EmployeeId,
TaskId = employeeTasksViewModel.TaskId,
TotalNoOfHours = employeeTasksViewModel.TotalNoOfHours,
CurrentDate = employeeTasksViewModel.CurrentDate,
Priority = employeeTasksViewModel.Priority,
PayPerTask = employeeTasksViewModel.PayPerTask,
});
}
public async Task <ActionResult> CreateAsync(EmployeeTasksViewModel employeeTasksViewModel)
{
_logger.LogInformation("Creating New Employee Task");
bool isEmployeeHaveCapacity = true;
isEmployeeHaveCapacity = await IsEmployeeAvailable(employeeTasksViewModel, isEmployeeHaveCapacity);
//checking model state
if (ModelState.IsValid)
{
if (isEmployeeHaveCapacity)
{
try
{
await GetCurrentRatePerHour(employeeTasksViewModel);
var emp = await this.employeeTaskService.CreateEmployeeTask(_objectMapper.EmployeeTasksViewModelToEmployeeTasks(employeeTasksViewModel));
return(RedirectToAction("Index"));
}
catch (Exception ex)
{
_logger.LogError("Error Creating Employee Task {0}", ex.Message);
return(View(ex.InnerException.Message));
}
}
else
{
ModelState.AddModelError("TotalNoOfHours", "Employee doesnt have capacity to Assgin this task");
}
}
EmployeeTasksViewModel empTaskView = await LoadEmployeeDetails();
return(View(empTaskView));
}
