public async Task <bool> CreateEmployee(EmployeeServiceModel employee)
{
try
{
_unitOfWork.BeginTransaction();
var model = _mapper.Map <Employee>(employee);
var employeeRepo = _unitOfWork.GetRepository <Employee>();
var locationRepo = _unitOfWork.GetRepository <Location>();
var salaryRepo = _unitOfWork.GetRepository <Salary>();
await locationRepo.AddItemAsync(model.Location);
await salaryRepo.AddItemAsync(model.Salary);
await employeeRepo.AddItemAsync(model);
await _unitOfWork.CommitAsync();
return(true);
}
catch
{
await _unitOfWork.RollbackAsync();
return(false);
}
}
public async Task <bool> UpdateEmployee(EmployeeServiceModel employee)
{
var model = _mapper.Map <Employee>(employee);
try
{
_unitOfWork.BeginTransaction();
await _unitOfWork.GetRepository <Employee>().UpdateAsync(model);
var locationRepo = _unitOfWork.GetRepository <Location>();
var employeeLocation = locationRepo.GetById(model.Location.Id);
employeeLocation = _mapper.Map(model.Location, employeeLocation);
await locationRepo.UpdateAsync(employeeLocation);
await _unitOfWork.CommitAsync();
return(true);
}
catch
{
await _unitOfWork.RollbackAsync();
return(false);
}
}
public EmployeeServiceModel GetUserByUsername(string username)
{
var reader = this.ExecuteReader(QueryConstants.GetUserByUsername, new Dictionary <string, object> {
{ "@username", username }
});
var counter = 0;
EmployeeServiceModel user = null;
while (reader.Read())
{
counter++;
var userId = (int)reader[0];
var usernameDb = (string)reader[1];
var email = (string)reader[2];
var imageUrl = (string)reader[3];
var birthDate = (DateTime)reader[4];
var passwordHash = (string)reader[5];
var passwordSalt = (string)reader[6];
user = new EmployeeServiceModel(userId, username, email, imageUrl, birthDate, passwordHash, passwordSalt);
}
if (counter > 1)
{
throw new InvalidOperationException("Username must be unique");
}
return(user);
}
public IActionResult Details(string id)
{
EmployeeServiceModel employee = this.employeesService.GetById(id);
if (employee.FullName == null)
{
return(this.BadRequest());
}
var model = new EmployeeDetailsViewModel
{
Id = employee.Id,
FullName = employee.FullName,
PhoneNumber = employee.PhoneNumber,
Email = employee.Email,
HomeAddress = employee.HomeAddress,
ImageUrl = employee.ImageUrl,
OperatingLocation = employee.OperatingLocation,
// TODO: add opLoc img
JobPosition = employee.JobPosition,
// TODO: add job position qualifications table
};
return(this.View(model));
}
public async Task <EmployeeServiceModel> UpdateAsync(EmployeeServiceModel model, CancellationToken cancellation = default)
{
try
{
var employee = await employeeDbContext.Employees.SingleOrDefaultAsync(item => item.Id == model.Id);
_mapper.Map <EmployeeServiceModel, EmployeeEntity>(model, employee);
await SaveChangesAsync(employee, DataAccess.Enums.EntityState.Upadet);
return(_mapper.Map <EmployeeServiceModel>(employee));
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <EmployeeServiceModel> CreateAsync(EmployeeServiceModel model, CancellationToken cancellation = default)
{
try
{
var entity = _mapper.Map <EmployeeEntity>(model);
await employeeDbContext.Employees.AddAsync(entity);
await SaveChangesAsync(entity, DataAccess.Enums.EntityState.Create);
return(_mapper.Map <EmployeeServiceModel>(entity));
}
catch (Exception ex)
{
throw ex;
}
}
public IActionResult Delete(string id)
{
EmployeeServiceModel employee = this.employeesService.GetById(id);
if (employee.FullName == null)
{
return(this.BadRequest());
}
var model = new DeleteEmployeeViewModel
{
Id = employee.Id,
FullName = employee.FullName,
OperatingLocation = employee.OperatingLocation,
JobPosition = employee.JobPosition,
};
return(this.View(model));
}
public IActionResult Edit(string id)
{
EmployeeServiceModel employee = this.employeesService.GetById(id);
if (employee.FullName == null)
{
return(this.BadRequest());
}
var model = new EmployeeInputModel
{
JobPositionId = employee.JobPositionId,
JobPositions = this.jobPositionsService.GetAll().Select(x => new JobPositionsDropdownViewModel
{
Id = x.Id,
JobPositionName = x.Name,
}),
// TODO: add job positions qualifications table
OperatingLocationId = employee.OperatingLocationId,
OperatingLocations = this.operatingLocationsService.GetAll().Select(x => new OperatingLocationsDropdownViewModel
{
Id = x.Id,
Town = x.Town,
Address = x.Address,
}),
// TODO: add opLoc img
Id = employee.Id,
FirstName = employee.FirstName,
MiddleName = employee.MiddleName,
LastName = employee.LastName,
Phone = employee.PhoneNumber,
Email = employee.Email,
Town = employee.Town,
Address = employee.Address,
ImageUrl = employee.ImageUrl,
};
return(this.View(model));
}
//public async System.Threading.Tasks.Task<ActionResult> Create(Employee employee, FormCollection data)
public ActionResult Create(Employee employee, FormCollection data)
{
var currentUser = (User)Session["CurrentUser"];
var userName = string.Empty;
if (currentUser != null)
{
userName = currentUser.User_Name;
}
var dateCreated = DateTime.Now;
var createdBy = userName;
const bool isActive = true;
const bool isDeleted = false;
var auditTrail = new AuditTrailModel();
#region ModelState && CreateEmployee
if (ModelState.IsValid)
{
var userModel = new UserModel();
#region Check Existance (Email, First Name, Last Name)
var employeemodel = new EmployeeModel();
bool checkIfEmployeeExists = employeemodel.CheckIfEmployeeExists(employee.User.Email_Address, employee.User.First_Name, employee.User.Last_Name);
if (checkIfEmployeeExists == false)
{
// TODO: fix created-by field
var createEmployee = employeemodel.CreateEmployee(employee.User.First_Name, employee.User.Last_Name, employee.User.Initials, employee.User.Email_Address,
employee.Persal_Number, employee.Head_Of_Department_Id, employee.Supervisor_Id, employee.Phone_Number, employee.Mobile_Phone_Number, employee.Gender_Id,
employee.Race_Id, employee.ID_Number, employee.Job_Position_Id, employee.Paypoint_Id, employee.Service_Office_Id, employee.Salary_Level_Id,
employee.Is_Shift_Worker, employee.Is_Casual_Worker, isActive, isDeleted, dateCreated, createdBy,
employee.Is_SocialWorker, employee.PracticeNumber, currentUser.User_Id);
if (createEmployee == null)
{
ViewBag.Message = "An Error Occurred, Please contact support";
return(View(employee));
}
else
{
auditTrail.InsertAuditTrail(userName, "Add New Employee Details", "Admin");
}
#endregion
#region Link Roles
var roleIds = new List <int>();
if (employee.User.Posted_Roles != null)
{
foreach (var roleId in employee.User.Posted_Roles.Role_IDs)
{
var roleIdValue = int.Parse(roleId);
roleIds.Add(roleIdValue);
}
}
userModel.AddUserToRole(createEmployee.User.User_Id, roleIds);
#endregion
#region link Selected Groups
var groupIds = new List <int>();
if (employee.User.Posted_Groups != null)
{
foreach (var groupId in employee.User.Posted_Groups.Group_IDs)
{
var groupIdValue = int.Parse(groupId);
groupIds.Add(groupIdValue);
}
}
userModel.AddUserToGroup(createEmployee.User.User_Id, groupIds);
#endregion
#region employee services and roles
var employeeServicesM = new EmployeeServiceModel();
var value = data["ServiceList"].ToString();
if (value != null)
{
string[] selectedServiceArray = data["ServiceList"].ToString().Split(',');
employeeServicesM.Delete(Convert.ToInt32(createEmployee.Employee_Id));
foreach (string i in selectedServiceArray)
{
employeeServicesM.CreateEmployeeService(createEmployee.Employee_Id, Convert.ToInt32(i), currentUser.User_Id);
}
auditTrail.InsertAuditTrail(userName, "Add New Employee Services" + ":" + value, "Admin");
}
var employeerolesM = new EmployeeRolesModel();
var value2 = data["JobPositionList"].ToString();
if (value2 != null)
{
string[] selectedRoleArray = data["JobPositionList"].ToString().Split(',');
employeerolesM.DeleteEmployeeJobPositions(Convert.ToInt32(createEmployee.Employee_Id));
foreach (string i in selectedRoleArray)
{
employeerolesM.CreateEmployeeJobPosition(createEmployee.Employee_Id, Convert.ToInt32(i), currentUser.User_Id);
}
auditTrail.InsertAuditTrail(userName, "Add New Employee Job position" + ":" + value2, "Admin");
}
#endregion
}
else
{
TempData["EnteredUser"] = "******" + employee.User.First_Name + " " + employee.User.Last_Name + " with persal #:" + employee.Persal_Number;
return(RedirectToAction("DoesExist"));
}
return(RedirectToAction("Index", "Employee"));
}
#endregion
#region Services && Job position
var employeeServices = new ProblemCategoryModel();
var employeeJobPosition = new JobPositionModel();
List <SelectListItem> AvailableEmployeeServices = new List <SelectListItem>();
foreach (var item in employeeServices.GetListOfProblemCategories())
{
var SelectItem = new SelectListItem();
bool itemSelected = false;
AvailableEmployeeServices.Add(new SelectListItem
{
Text = item.Description,
Value = item.Problem_Category_Id.ToString(),
Selected = itemSelected
});
}
ViewBag.AvailableEmployeeServices = AvailableEmployeeServices;
List <SelectListItem> AvailableEmployeeJobPosition = new List <SelectListItem>();
foreach (var item in employeeJobPosition.GetListOfJobPositions())
{
var SelectItem = new SelectListItem();
bool itemSelected = false;
AvailableEmployeeJobPosition.Add(new SelectListItem
{
Text = item.Description,
Value = item.Job_Position_Id.ToString(),
Selected = itemSelected
});
}
ViewBag.AvailableJobPosition = AvailableEmployeeJobPosition;
#endregion
return(View(employee));
}
public ActionResult Edit(Employee employee, FormCollection data)
{
var currentUser = (User)Session["CurrentUser"];
var userName = string.Empty;
if (currentUser != null)
{
userName = currentUser.User_Name;
}
var dateLastModified = DateTime.Now;
var modifiedBy = userName;
const bool isActive = true;
const bool isDeleted = false;
var auditTrail = new AuditTrailModel();
if (ModelState.IsValid)
{
var userModel = new UserModel();
var employeeModel = new EmployeeModel();
var updatedEmployee = employeeModel.EditEmployee(employee.Employee_Id, employee.User.First_Name, employee.User.Last_Name,
employee.User.Initials, employee.User.Email_Address, employee.Persal_Number, employee.Head_Of_Department_Id,
employee.Supervisor_Id, employee.Phone_Number, employee.Mobile_Phone_Number, employee.Gender_Id, employee.Race_Id,
employee.ID_Number, employee.Job_Position_Id, employee.Paypoint_Id, employee.Service_Office_Id, employee.Salary_Level_Id,
employee.Is_Shift_Worker, employee.Is_Casual_Worker, isActive, isDeleted, dateLastModified, modifiedBy, employee.Is_SocialWorker, employee.PracticeNumber, employee.Facility_Id
);
if (updatedEmployee == null)
{
ViewBag.Message = "An Error Occured, Please contact Support";
return(View(employee));
}
else
{
auditTrail.InsertAuditTrail(userName, "Update Employee Details", "Admin");
}
// Link Selected Roles
var roleIds = new List <int>();
if (employee.User.Posted_Roles != null)
{
foreach (var roleId in employee.User.Posted_Roles.Role_IDs)
{
var roleIdValue = int.Parse(roleId);
roleIds.Add(roleIdValue);
}
}
userModel.AddUserToRole(updatedEmployee.User.User_Id, roleIds);
// Link Selected Groups
var groupIds = new List <int>();
if (employee.User.Posted_Groups != null)
{
foreach (var groupId in employee.User.Posted_Groups.Group_IDs)
{
var groupIdValue = int.Parse(groupId);
groupIds.Add(groupIdValue);
}
}
userModel.AddUserToGroup(updatedEmployee.User.User_Id, groupIds);
#region employee services and roles
var employeeServicesM = new EmployeeServiceModel();
if (data["ServiceList"] != null)
{
//var value = data["ServiceList"].ToString();
string[] selectedServiceArray = data["ServiceList"].ToString().Split(',');
employeeServicesM.Delete(Convert.ToInt32(updatedEmployee.Employee_Id));
foreach (string i in selectedServiceArray)
{
employeeServicesM.CreateEmployeeService(updatedEmployee.Employee_Id, Convert.ToInt32(i), currentUser.User_Id);
}
auditTrail.InsertAuditTrail(userName, "Update Employee Services" + ":" + data["ServiceList"], "Admin");
}
var employeerolesM = new EmployeeRolesModel();
if (data["JobPositionList"] != null)
{
//var value2 = data["JobPositionList"].ToString();
string[] selectedRoleArray = data["JobPositionList"].ToString().Split(',');
employeerolesM.DeleteEmployeeJobPositions(Convert.ToInt32(updatedEmployee.Employee_Id));
foreach (string i in selectedRoleArray)
{
employeerolesM.CreateEmployeeJobPosition(updatedEmployee.Employee_Id, Convert.ToInt32(i), currentUser.User_Id);
}
auditTrail.InsertAuditTrail(userName, "Update Employee Job position" + ":" + data["JobPositionList"], "Admin");
}
#endregion
return(RedirectToAction("Index", "Employee"));
}
return(View(employee));
}
public async Task <IActionResult> CreateEmployee(CreateEmployeeViewModel model)
{
if (!ModelState.IsValid)
{
var selectListModels = await FillSelectLists(model.CountryId, model.CompanyId);
model = _mapper.Map(selectListModels, model);
return(View(model));
}
//VERY SPAGHETTI
//Register Identity
var result = new IdentityResult();
var user = new UserServiceModel {
Email = model.Email, UserName = model.Email
};
result = await _accountService.CreateUserAsync(user, "P@ssw0rd");
if (model.IsManager && result.Succeeded)
{
user = _mapper.Map <UserServiceModel>(await _accountService.GetByIdAsync(user.Id.ToString()));
result = await _adminService.SetUserAsManager(user);
}
//If there was an error with identity, redisplay form
if (!result.Succeeded)
{
var selectListModels = await FillSelectLists(model.CountryId, model.CompanyId);
model = _mapper.Map(selectListModels, model);
model.StatusMessage = "Error, could not create employee";
return(View(model));
}
//Register Employee
var department = await _adminService.GetDepartmentById(model.DepartmentId);
var job = await _adminService.GetJobById(model.JobId);
var createModel = new EmployeeServiceModel
{
Department = department,
Job = job,
HiredDate = DateTime.UtcNow,
Salary = new SalaryServiceModel
{
Amount = model.SalaryAmount,
Currency = await _nomenclatureService.GetCurrency(model.CurrencyId),
SalaryType = await _nomenclatureService.GetSalaryType(model.SalaryTypeId)
},
HrId = Guid.NewGuid()
};
createModel = _mapper.Map(model, createModel);
createModel.Location.City = await _nomenclatureService.GetCity(model.CityId);
if (!await _adminService.CreateEmployee(createModel))
{
//if employee creation failed, we need to delete the user associated with it
await _adminService.DeleteUser(user);
var selectListModels = await FillSelectLists(model.CountryId, model.CompanyId);
model = _mapper.Map(selectListModels, model);
model.StatusMessage = "Error, could not create employee";
return(View(model));
}
StatusMessage = "Employee Successfuly registered!";
return(RedirectToAction(nameof(Index)));
}
