public async Task UpdateEmployeeAsync(Guid id, UpdateEmployeeModel updateEmployeeModel)
{
_logger.LogInformation(
"Updating employee {id} - {updateEmployeeModel}",
id,
JsonConvert.SerializeObject(updateEmployeeModel));
// Run some validation rules, simple RPCs ...
await Task.CompletedTask;
var entity = await _employeesContext.Employees.FindAsync(id);
if (entity == null)
{
return;
}
entity.TechSkills.Clear();
updateEmployeeModel
.TechSkills
.ForEach(i => entity.TechSkills.Add(new TechSkill {
Description = i
}));
_mapper.Map(updateEmployeeModel, entity);
await _employeesContext.SaveChangesAsync();
}
public async Task UpdateEmployeeAsync_should_return_true_when_updated()
{
// Arange
var employee = new Employee
{
Email = "*****@*****.**",
EmployeeCardId = Guid.NewGuid().ToString(),
EmployeeId = Guid.NewGuid().ToString(),
MobileNumber = "07777777777",
Name = "Joe Bloggs",
Pin = "0123"
};
await this.Context.Employees.InsertOneAsync(employee);
var updateModel = new UpdateEmployeeModel
{
Email = "updated",
EmployeeId = "updated",
MobileNumber = "updated",
Name = "updated"
};
// Act
var result = await this.EmployeeRepository.UpdateEmployeeAsync(employee.EmployeeCardId, updateModel);
// Assert
Assert.True(result);
}
public async Task <IActionResult> PutEmployee(int id, UpdateEmployeeModel employeeEntity)
{
if (id != employeeEntity.Id)
{
return(BadRequest());
}
try
{
await _mediator.Send(new UpdateEmployeeCommand(employeeEntity));
}
catch (DBConcurrencyException)
{
var exists = await _mediator.Send(new GetEmployeeExistsQuery(id));
if (!exists)
{
return(NotFound());
}
throw;
}
return(NoContent());
}
public async Task <IActionResult> UpdateEmployee([FromBody] UpdateEmployeeModel updateEmployeeModel)
{
UpdateEmployeeDto updateEmployeeDto = _mapper.Map <UpdateEmployeeDto>(updateEmployeeModel);
await _employeeService.UpdateEmplyeeAsync(updateEmployeeDto);
return(Ok());
}
public async Task <JsonResult> Update(UpdateEmployeeModel employee)
{
if (ModelState.IsValid)
{
var result = await _employeeOrchestrator.UpdateEmployee(new EmployeeViewModel
{
RecordGuid = employee.RecordGuid,
FirstName = employee.FirstName,
MiddleName = employee.MiddleName,
LastName = employee.LastName,
BirthDate = employee.BirthDate,
HireDate = employee.HireDate,
Department = employee.Department,
JobTitle = employee.JobTitle,
PayRate = employee.PayRate,
SalaryType = employee.SalaryType,
EmployeeId = employee.EmployeeId,
AvailableHours = employee.AvailableHours
});
return(Json(result, JsonRequestBehavior.AllowGet));
}
if (employee.RecordGuid == Guid.Empty)
{
return(Json(false, JsonRequestBehavior.AllowGet));
}
return(Json(false, JsonRequestBehavior.AllowGet));
}
public async Task <bool> UpdateEmployeeWithDetailsById(Guid BusinessID, Guid employeeId, UpdateEmployeeModel updateEmployeeModel)
{
var businessID = new Npgsql.NpgsqlParameter("@thebusinessid", BusinessID);
var employeeID = new Npgsql.NpgsqlParameter("@theempid", employeeId);
var empName = new Npgsql.NpgsqlParameter("@theempfullname", updateEmployeeModel.EmployeeName);
var empGender = new Npgsql.NpgsqlParameter("@theempgender", updateEmployeeModel.EmployeeGender);
var empSSN = new Npgsql.NpgsqlParameter("@theempssn", updateEmployeeModel.EmployeeSSN);
var empDepartmentID = new Npgsql.NpgsqlParameter("@thedeptid", updateEmployeeModel.DepartmentID);
var empBps = new Npgsql.NpgsqlParameter("@bps", updateEmployeeModel.BPS);
var empDesignation = new Npgsql.NpgsqlParameter("@theempdesignation", updateEmployeeModel.EmpDesignation);
var empPaCountry = new Npgsql.NpgsqlParameter("@theemppacountry", updateEmployeeModel.PACountry);
var empPaCity = new Npgsql.NpgsqlParameter("@theemppacity", updateEmployeeModel.PACity);
var empPaProvince = new Npgsql.NpgsqlParameter("@theemppaprovince", updateEmployeeModel.PAProvince);
var empPaZip = new Npgsql.NpgsqlParameter("@theemppazip", updateEmployeeModel.PAZip);
var empMaCountry = new Npgsql.NpgsqlParameter("@theempmacountry", updateEmployeeModel.MACountry);
var empMaCity = new Npgsql.NpgsqlParameter("@theempmacity", updateEmployeeModel.MACity);
var empMaProvince = new Npgsql.NpgsqlParameter("@theempmaprovince", updateEmployeeModel.MAProvince);
var empMaZip = new Npgsql.NpgsqlParameter("@theempmazip", updateEmployeeModel.MAZip);
var empEmail = new Npgsql.NpgsqlParameter("@theempemail", updateEmployeeModel.EmpEmail);
var empJoiningDate = new Npgsql.NpgsqlParameter("@theempjoiningdate", NpgsqlDbType.Date)
{
Direction = ParameterDirection.InputOutput,
Value = !string.IsNullOrEmpty(updateEmployeeModel.EmpJoiningDate) ? Convert.ToDateTime(updateEmployeeModel.EmpJoiningDate) : (object)DBNull.Value
};
var empAppDate = new Npgsql.NpgsqlParameter("@theempappointmentdate", NpgsqlDbType.Date)
{
Direction = ParameterDirection.InputOutput,
Value = !string.IsNullOrEmpty(updateEmployeeModel.EmpAppointmentDate) ? Convert.ToDateTime(updateEmployeeModel.EmpAppointmentDate) : (object)DBNull.Value
};
var empDesc = new Npgsql.NpgsqlParameter("@thedescription", updateEmployeeModel.Description);
var empPhoto = new Npgsql.NpgsqlParameter("@thephoto", updateEmployeeModel.Photo);
var empSkype = new Npgsql.NpgsqlParameter("@theskypeusername", updateEmployeeModel.SkypeUserName);
var empOfficePhoneNo = new Npgsql.NpgsqlParameter("@theempofficephoneno", updateEmployeeModel.EmpOfficeNo);
var empCellNo = new Npgsql.NpgsqlParameter("@theempcellno", updateEmployeeModel.EmpCellNo);
UpdateEmployeeModel updateEmployeeModel1 = await Task.Run(() => _projectContextDB.UpdateEmployeeModel.FromSqlRaw("select * from updateemployee(@thebusinessid,@theempid,@theempfullname," +
"@theempgender,@theempssn,@thedeptid,@bps,@theempdesignation,@theemppacountry,@theemppacity,@theemppaprovince,@theemppazip," +
"@theempmacountry,@theempmacity,@theempmaprovince,@theempmazip,@theempemail,@theempjoiningdate,@theempappointmentdate, " +
"@thedescription,@thePhoto,@theskypeusername,@theempofficephoneno,@theempcellno) as emp_id ", businessID, employeeID, empName, empGender, empSSN, empDepartmentID, empBps, empDesignation,
empPaCountry, empPaCity, empPaProvince, empPaZip, empMaCountry, empMaCity, empMaProvince, empMaZip, empEmail, empJoiningDate, empAppDate,
empDesc, empPhoto, empSkype, empOfficePhoneNo, empCellNo)
.Select(e => new UpdateEmployeeModel()
{
EmployeeID = e.EmployeeID
}).FirstOrDefault());
if (updateEmployeeModel1.EmployeeID != new Guid())
{
return(true);
}
return(false);
}
public Employee Create(Employee model, UpdateEmployeeModel modelUpdate)
{
model.Name = modelUpdate.Name;
model.FirstName = modelUpdate.FirstName;
model.Age = modelUpdate.Age;
return(model);
}
public byte UpdateEmployee(Guid id, UpdateEmployeeModel employee)
{
if (id != employee.Id)
{
return(3);
}
Employee _employee = context.Employees.Find(id);
if (_employee != null)
{
if (employee.Name != null)
{
_employee.Name = employee.Name;
}
if (employee.Address != null)
{
_employee.Address = employee.Address;
}
if (employee.Phone != 0)
{
_employee.Phone = employee.Phone;
}
if (employee.Country != null)
{
_employee.Country = employee.Country;
}
if (employee.Zip != 0)
{
_employee.Zip = employee.Zip;
}
}
else
{
return(2);
}
context.Entry(_employee).State = EntityState.Modified;
try
{
context.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!context.Employees.Any(e => e.Id == id))
{
return(2);
}
else
{
throw;
}
}
return(1);
}
public static UpdateEmployeeModel Sanitize(this UpdateEmployeeModel model)
{
var context = Mapper.Map <UpdateEmployeeModel>(model);
context.Email = context.Email?.SanitizeEmail();
context.FirstName = context.FirstName?.Sanitize();
context.LastName = context.LastName?.Sanitize();
return(context);
}
public IActionResult UpdateEmployee([FromBody] UpdateEmployeeModel employeeModel)
{
try
{
return(Ok(employeeRepository.UpdateEmployee(employeeModel)));
}
catch (Exception e)
{
return(Problem(e.Message));
}
}
public ActionResult Edit(UpdateEmployeeModel model)
{
try
{
//Explicitly Validate Model for UserRole
if (model.UserRole != EmployeeUserRole.Admin && model.UserRole != EmployeeUserRole.Employee)
{
ModelState.AddModelError("updatestatus", "An Employee Needs to be assigned one of the Roles");
}
if (ModelState.IsValid)
{
// Get previous details
var existinguser = MembershipService.GetUser(model.UserGuid, false);
if (existinguser == null)
{
throw new InvalidOperationException("Sorry the update cannot be done as no such user exist");
}
existinguser.Address = model.Address;
existinguser.Name = model.EmployeeName;
existinguser.MobileNumber = UInt64.Parse(model.MobileNumber ?? "0");
existinguser.UserRole = (UserBase.RestaurantUserRole)(int) model.UserRole;
//And push the changed details
MembershipService.UpdateUser(existinguser);
TempData[TempDataStringResuorce.ActionResultNotification] = new ActionResultNotification
{
Message = String.Format("Details for {0} was successfully Updated", model.EmployeeName),
Result = true,
State = ActionResultNotification.MessageState.Information
};
return(RedirectToAction("Index"));
}
// If we got this far, something failed, redisplay form
TempData[TempDataStringResuorce.ActionResultNotification] = new ActionResultNotification
{
Message = "Cannot Update the details of the employee with given details, please try again",
Result = false,
State = ActionResultNotification.MessageState.Warning
};
ViewBag.PasswordLength = MembershipService.MinPasswordLength;
return(View(model));
}
catch (Exception e)
{
TempData[TempDataStringResuorce.ActionResultNotification] = new ActionResultNotification
{
Message = e.Message,
Result = false,
State = ActionResultNotification.MessageState.Error
};
return(View(model));
}
}
public async Task <ServiceResponseModel <Employee> > UpdateEmployeeAsync(UpdateEmployeeModel updateEmployee)
{
if (updateEmployee.Id <= 0)
{
return(ServiceResponseUtil.GetServiceResponse(
ServiceStatusCode.InvalidId, new Employee()));
}
var updatedEmployee = await _employeeRepository.UpdateEmployeeAsync(updateEmployee);
var updateStatus = updatedEmployee.Id > 0 ? ServiceStatusCode.Success : ServiceStatusCode.Error;
return(ServiceResponseUtil.GetServiceResponse(updateStatus, updatedEmployee));
}
public bool UpdateEmployee(Guid id, UpdateEmployeeModel employee)
{
byte result = repository.UpdateEmployee(id, employee);
if (result == 1)
{
return(true);
}
else if (result == 2)
{
throw new EmployeeNotFoundException($"Employee with ID: {id} does not exist!");
}
return(false);
}
public async Task <IActionResult> PutEmployee(int id, UpdateEmployeeModel message)
{
if (id < 1)
{
return(BadRequest());
}
var employee = new Employee();
employee.UserID = id;
employee.EmployeeName = message.EmployeeName;
employee.Active = message.Active;
await _employeeService.PutEmployee(id, employee);
return(NoContent());
}
public ActionResult Update(UpdateEmployeeModel updateemployeemodel, FormCollection form, string submit)
{
switch (submit)
{
case "Sil":
{
var emp = db.T_Employee.Find(updateemployeemodel._Employee.employee_id);
if (emp == null)
{
return(HttpNotFound());
}
db.T_Employee.Remove(emp);
break;
}
default:
{
var hash = new HashIt();
if (updateemployeemodel._Employee.employee_id == 0)
{
updateemployeemodel._Employee.department_id = int.Parse(form["DropDownListDepartmants"].ToString());
updateemployeemodel._Employee.employee_authority_id = int.Parse(form["DropDownListAuthorities"].ToString());
updateemployeemodel._Employee.employee_password = hash.Hashit(updateemployeemodel._Employee.employee_password);
}
else
{
if (updateemployeemodel._Employee.employee_password == null)
{
updateemployeemodel._Employee.employee_password = db.T_Employee.Find(updateemployeemodel._Employee.employee_id).employee_password;
}
else
{
updateemployeemodel._Employee.employee_password = hash.Hashit(updateemployeemodel._Employee.employee_password);
}
db.T_Employee.Find(updateemployeemodel._Employee.employee_id).department_id = form["DropDownListDepartmants"].ToString() == "" ? db.T_Employee.Find(updateemployeemodel._Employee.employee_id).department_id : int.Parse(form["DropDownListDepartmants"]);
db.T_Employee.Find(updateemployeemodel._Employee.employee_id).employee_authority_id = form["DropDownListAuthorities"].ToString() == "" ? db.T_Employee.Find(updateemployeemodel._Employee.employee_id).employee_authority_id : int.Parse(form["DropDownListAuthorities"]);
}
db.T_Employee.AddOrUpdate(updateemployeemodel._Employee);
break;
}
}
db.SaveChanges();
return(RedirectToAction("Index", "Employees"));
}
public async Task UpdateEmployeeAsync_should_return_false_when_not_updated()
{
// Arrange
var updateModel = new UpdateEmployeeModel
{
Email = "updated",
EmployeeId = "updated",
MobileNumber = "updated",
Name = "updated"
};
// Act
var result = await this.EmployeeRepository.UpdateEmployeeAsync(Guid.NewGuid().ToString(), updateModel);
// Assert
Assert.False(result);
}
public async Task <EmployeeModel> UpdateEmployee(long id, UpdateEmployeeModel model)
{
var slip = await Employees.FindAsync(id);
if (slip != null)
{
var update = new Employee
{
Id = id
};
var result = Employees.Update(update);
return(new EmployeeModel(result.Entity));
}
return(null);
}
public async Task <CustomResponse> Update(Guid id, UpdateEmployeeModel UpdateRequest)
{
EmployeeDto appDeviceDto = _unitOfWork.EmployeeRepository.Find(id);
if (appDeviceDto == null)
{
return(_responsMessages.EmployeeNotFound);
}
appDeviceDto.Name = UpdateRequest.Name;
appDeviceDto.FatherName = UpdateRequest.FatherName;
appDeviceDto.Age = UpdateRequest.Age;
appDeviceDto.Type = UpdateRequest.Type;
await _unitOfWork.SaveChangesAsync();
return(_responsMessages.EmployeeUpdatedSuccessfully);
}
public IActionResult UpdateEmployeePassword([FromBody] UpdateEmployeeModel employeeModel)
{
int currentUserId = int.Parse(User.Identity.Name);
if (currentUserId != employeeModel.EmployeeId)
{
return(Forbid());
}
try
{
return(Ok(employeeRepository.UpdateEmployee(employeeModel)));
}
catch (Exception e)
{
return(Problem(e.Message));
}
}
public async Task <JsonResult> UpdateStudent(UpdateEmployeeModel employee)
{
if (employee.EmployeeId == Guid.Empty)
{
return(Json(false, JsonRequestBehavior.AllowGet));
}
var result = await _employeeOrchestrator.UpdateEmployee(new EmployeeViewModel
{
EmployeeId = Guid.NewGuid(),
EmployeeName = employee.Name,
Email = employee.Email,
Role = employee.Role
});
return(Json(result, JsonRequestBehavior.AllowGet));
}
public async Task <IHttpActionResult> UpdateEmployeeAsync(int Id, [FromBody] UpdateEmployeeModel model)
{
if (model == null)
{
return(BadRequest());
}
if (!(await _existEmployeeQuery.ExecuteAsync(Id)))
{
return(Content(HttpStatusCode.NotFound, EmployeeMessages.EmployeeDoesNotExistMessage));
}
var employee = await _updateEmployeeCommand.ExecuteAsync(Id, model);
var returnEmployee = MapEmployee(employee);
return(CreatedAtRoute("GetEmployeeByIdAsync", new { Id = employee.Id }, returnEmployee));
}
public IActionResult Put(Guid id, [FromBody] UpdateEmployeeModel employee)
{
try
{
if (service.UpdateEmployee(id, employee))
{
return(Ok());
}
return(BadRequest());
}
catch (EmployeeNotFoundException enf)
{
return(NotFound(enf.Message));
}
catch (Exception)
{
return(StatusCode(500, "Internal server error occurred"));
}
}
public async Task <ActionResult> UpdateEmployee(int employeeId, [FromBody] UpdateEmployeeModel model)
{
try
{
if (employeeId != model.EmployeeId)
{
ModelState.AddModelError(nameof(model.EmployeeId), "The EmployeeId does not match with route value.");
return(BadRequest(ModelState));
}
bool isExistent = await _departmentService.ExistsAsync(model.DepartmentId);
if (!isExistent)
{
ModelState.AddModelError(nameof(model.DepartmentId), "The Department does not exist.");
return(BadRequest(ModelState));
}
UpdateEmployeeDto updateEmployeeDto = new UpdateEmployeeDto
{
EmployeeId = model.EmployeeId,
EmployeeName = model.EmployeeName,
DepartmentId = model.DepartmentId,
DateOfBirth = model.DateOfBirth,
Email = model.Email,
PhoneNumber = model.PhoneNumber
};
await _employeeService.UpdateAsync(updateEmployeeDto);
return(Ok());
}
catch (Exception exception)
{
await _exceptionLogger.LogAsync(exception);
return(StatusCode(StatusCodes.Status500InternalServerError));
}
}
public async Task <JsonResult> UpdateEmployee(UpdateEmployeeModel employee)
{
if (employee.EmployeeId == null)
{
return(Json(false, JsonRequestBehavior.AllowGet));
}
var result = await _employeeOrchestrator.UpdateEmployee(new EmployeeViewModel
{
FirstName = employee.FirstName,
MiddleName = employee.MiddleName,
LastName = employee.LastName,
BirthDate = employee.BirthDate,
HireDate = employee.HireDate,
Department = employee.Department,
JobTitle = employee.JobTitle,
Salary = employee.Salary,
EmployeeId = employee.EmployeeId,
AvailableHours = employee.AvailableHours
});
return(Json(result, JsonRequestBehavior.AllowGet));
}
public async Task <IActionResult> UpdateAsync([FromBody] UpdateEmployeeModel model)
{
try
{
var employee = Mapper.Map <Employee>(model);
await _employeeService.UpdateAsync(employee);
return(NoContent());
}
catch (EmployeeExistException ex)
{
_log.WarningWithDetails(ex.Message, model.Sanitize());
return(BadRequest(ErrorResponse.Create(ex.Message)));
}
catch (EmployeeNotFoundException ex)
{
_log.WarningWithDetails(ex.Message, model.Sanitize());
return(NotFound(ErrorResponse.Create(ex.Message)));
}
}
public async Task Should_CorrectlyUpdateEmployee()
{
// Arrange
using var client = await _factory.CreateAuthenticatedHttpClientAsync();
var createEmployeeObj = new CreateEmployeeModel
{
Name = Id.StringValue1,
Active = true,
ChildrenCount = Id.IntAmount1,
DateOfBirth = Id.Date1,
StartOfEmployment = Id.DateRecent1
};
var employeeId = await CreateEmployee(client, createEmployeeObj);
// Act
var updateEmployeeObj = new UpdateEmployeeModel
{
Id = employeeId,
Name = Id.StringValue2,
Active = false,
ChildrenCount = Id.IntAmount2,
DateOfBirth = Id.Date2,
StartOfEmployment = Id.DateRecent2
};
var response = await client.PutAsync($"{_updateEmployeeEndpoint}/{employeeId}", updateEmployeeObj.AsJson());
// Assert
response.StatusCode.Should().Be(HttpStatusCode.NoContent);
response = await client.GetAsync($"{_getEmployeeEndpoint}/{employeeId}");
var content = await response.Content.ReadAsStringAsync();
var resultObj = JsonConvert.DeserializeObject <EmployeeModel>(content);
resultObj.Should().BeEquivalentTo(updateEmployeeObj);
}
public async Task <Employee> UpdateEmployeeAsync(UpdateEmployeeModel updateEmployeeModel)
{
var employeeList = await GetEmployeesAsync();
var employee = employeeList.FirstOrDefault(e => e.Id == updateEmployeeModel.Id);
if (employee == null)
{
return(new Employee());
}
employee.FirstName = updateEmployeeModel.FirstName;
employee.LastName = updateEmployeeModel.LastName;
employee.ManagerId = updateEmployeeModel.ManagerId;
employee.DateOfBirth = updateEmployeeModel.DateOfBirth;
employee.Designation = updateEmployeeModel.Designation;
employee.StartDate = updateEmployeeModel.StartDate;
employee.EndDate = updateEmployeeModel.EndDate;
employee.Department = updateEmployeeModel.Department;
employee.HourlyRate = updateEmployeeModel.HourlyRate;
SaveEmploye(employeeList);
return(employee);
}
public async Task <object> UpdateEmployeeWithDetailsById(Guid theBusinessId, Guid theEmployeeId, [FromBody] UpdateEmployeeModel updateEmployeeModel)
{
var errors = _employeeValidation.ValidateUpdateEmployeeData(updateEmployeeModel);
if (errors != null)
{
return(errors);
}
var response = await _employeeLogic.UpdateEmployeeWithDetailsById(theBusinessId, theEmployeeId, updateEmployeeModel);
if (response)
{
return(_employeeValidation.EmployeeUpdatedSucces());
}
return(_employeeValidation.EmployeeIdDoesNotExist(theEmployeeId));
}
public async Task <IActionResult> UpdateEmployeeData(Guid id, UpdateEmployeeModel model)
{
await _employeeService.UpdateEmployeeAsync(id, model);
return(NoContent());
}
//public void UpdateEmployee(UpdateEmployeeModel employeeModel)
//{
// bool updateUser = false;
// bool updateLoginInfo = false;
// Employee employeeDB = GetEntityById(employeeModel.EmployeeId);
// LoginInfo loginDB = loginInfoRepository.GetEntityByUserId(employeeModel.EmployeeId);
// if (employeeDB == null || loginDB == null)
// {
// return;
// }
// int roleId = -1;
// if (employeeModel.RoleDescription != null)
// {
// roleId = unitOfWork.RoleManager.GetAll().Where(x => x.RoleDescription == employeeModel.RoleDescription).FirstOrDefault().Id;
// }
// if ((!string.IsNullOrWhiteSpace(employeeModel.FirstName) && employeeModel.FirstName != employeeDB.FirstName)
// || (!string.IsNullOrWhiteSpace(employeeModel.MiddleName) && employeeModel.MiddleName != employeeDB.MiddleName)
// || (!string.IsNullOrWhiteSpace(employeeModel.LastName) && employeeModel.LastName != employeeDB.LastName)
// || (roleId != -1 && employeeDB.RoleId != roleId))
// {
// employeeDB.FirstName = employeeModel.FirstName;
// employeeDB.MiddleName = employeeModel.MiddleName;
// employeeDB.LastName = employeeModel.LastName;
// employeeDB.RoleId = roleId;
// updateUser = true;
// }
// if (!string.IsNullOrWhiteSpace(employeeModel.Password) && !VerifyPasswordHash(employeeModel.Password, loginDB.PasswordHash, loginDB.PasswordSalt))
// {
// byte[] passwordHash, passwordSalt;
// CreatePasswordHash(employeeModel.Password, out passwordHash, out passwordSalt);
// loginDB.PasswordSalt = passwordSalt;
// loginDB.PasswordHash = passwordHash;
// updateLoginInfo = true;
// }
// if (updateUser && updateLoginInfo)
// unitOfWork.EmployeeManager.UpdateUser(employeeDB, loginDB);
// else if (updateUser)
// unitOfWork.EmployeeManager.UpdateUser(employeeDB, null);
// else if (updateLoginInfo)
// unitOfWork.EmployeeManager.UpdateUser(null, loginDB);
//}
public string UpdateEmployee(UpdateEmployeeModel employeeModel)
{
bool updateUser = false;
bool updateLoginInfo = false;
Employee employeeDB = GetEntityById(employeeModel.EmployeeId);
LoginInfo loginDB = loginInfoRepository.GetEntityByUserId(employeeModel.EmployeeId);
if (employeeDB == null || loginDB == null)
{
return("Update failed! Could not find employee.");
}
int roleId = -1;
if (employeeModel.RoleDescription != null)
{
roleId = unitOfWork.RoleManager.GetAll().Where(x => x.RoleDescription == employeeModel.RoleDescription).FirstOrDefault().Id;
}
if ((!string.IsNullOrWhiteSpace(employeeModel.FirstName) && employeeModel.FirstName != employeeDB.FirstName) ||
(!string.IsNullOrWhiteSpace(employeeModel.MiddleName) && employeeModel.MiddleName != employeeDB.MiddleName) ||
(!string.IsNullOrWhiteSpace(employeeModel.LastName) && employeeModel.LastName != employeeDB.LastName) ||
(roleId != -1 && employeeDB.RoleId != roleId))
{
employeeDB.FirstName = employeeModel.FirstName;
employeeDB.MiddleName = employeeModel.MiddleName;
employeeDB.LastName = employeeModel.LastName;
employeeDB.RoleId = roleId;
updateUser = true;
}
if (!string.IsNullOrWhiteSpace(employeeModel.Password) && !VerifyPasswordHash(employeeModel.Password, loginDB.PasswordHash, loginDB.PasswordSalt))
{
byte[] passwordHash, passwordSalt;
CreatePasswordHash(employeeModel.Password, out passwordHash, out passwordSalt);
loginDB.PasswordSalt = passwordSalt;
loginDB.PasswordHash = passwordHash;
updateLoginInfo = true;
}
if (updateUser && updateLoginInfo)
{
try
{
unitOfWork.BeginTransaction();
unitOfWork.EmployeeManager.Update(employeeDB);
unitOfWork.SaveChanges();
unitOfWork.LoginInfoManager.Update(loginDB);
unitOfWork.SaveChanges();
unitOfWork.CommitTransaction();
}
catch (Exception e)
{
unitOfWork.RollbackTransaction();
return(e.Message);
}
}
else if (updateUser)
{
try
{
unitOfWork.EmployeeManager.Update(employeeDB);
unitOfWork.SaveChanges();
}
catch (Exception e)
{
return(e.Message);
}
}
else if (updateLoginInfo)
{
try
{
unitOfWork.LoginInfoManager.Update(loginDB);
unitOfWork.SaveChanges();
}
catch (Exception e)
{
return(e.Message);
}
}
return("Update sucsessfull.");
}
