public async Task <IActionResult> Edit(Guid id, [Bind("EmployeeID,EmployeeNumber,FirstName,LastName,CompanyEmail,PersonalEmail,IsActive,EmployeeID,ReportsTo,CanApprove")] UpdateEmployeeViewModel model)
{
if (id != model.EmployeeID)
{
return(NotFound());
}
ViewData["Approvers"] = GetApprovers(model.ReportsTo);
if (ModelState.IsValid)
{
try
{
await Mediator.Send(new UpdateEmployee_Request {
FirstName = model.FirstName,
LastName = model.LastName,
EmployeeNumber = model.EmployeeNumber,
CompanyEmail = model.CompanyEmail,
PersonalEmail = model.PersonalEmail,
ModifiedBy = User.Identity.Name,
IsActive = model.IsActive,
EmployeeID = model.EmployeeID,
ReportsTo = model.ReportsTo,
CanApprove = model.CanApprove,
});
return(Redirect(Url.Action("Index", "Employees")).WithSuccess("Success", "Updated employee details"));
}
catch (Exception ex)
{
ErrorResponse.AddError(ex.GetExceptionMessage());
}
}
return(View(model).WithDanger("Action cannot be completed", ErrorResponse.Message));
}
public async Task UpdateEmployee(UserManager <IdentityUser> _userManager, UpdateEmployeeViewModel model, ClaimsPrincipal user, SignInManager <IdentityUser> signInManager)
{
var employee = await _userManager.FindByIdAsync(model.Id);
employee.UserName = model.EmailAddress;
if (model.Password != null)
{
var code = await _userManager.GeneratePasswordResetTokenAsync(employee);
await _userManager.ResetPasswordAsync(employee, code, model.Password);
}
var role = _userManager.IsInRoleAsync(employee, "Admin").Result ? "Admin" : "Cashier";
var result = _userManager.IsInRoleAsync(employee, model.Role).Result ? true : false;
if (result == false)
{
await _userManager.RemoveFromRoleAsync(employee, role);
await _userManager.AddToRoleAsync(employee, model.Role);
}
await _userManager.UpdateNormalizedUserNameAsync(employee);
var name = user.Identity.Name;
if (name == employee.UserName)
{
await signInManager.RefreshSignInAsync(employee);
}
await _userManager.UpdateAsync(employee);
}
public IActionResult Put(int id, [FromBody] UpdateEmployeeViewModel employeeViewModel)
{
if (employeeViewModel != null)
{
employeeViewModel.ID = id;
if (string.IsNullOrEmpty(employeeViewModel.UserName))
{
employeeViewModel.UserName = iEmployeeRepository.GetEmployeeByID(employeeViewModel.ID).UserName;
}
//TO DO for later on: move the update logic for the employee position into a service
List <PositionApplicationRole> positions = iPositionRepository.GetPositions();
if (employeeViewModel.Position.Id == 0)
{
employeeViewModel.Position = iEmployeeRepository.GetEmployeeByID(employeeViewModel.ID).Position;
}
else
{
PositionApplicationRole employeePositionFromDropDownList = positions.Where(x => x.Id == employeeViewModel.Position.Id).FirstOrDefault();
employeeViewModel.Position = employeePositionFromDropDownList;
}
EmployeeApplicationUser employee = new EmployeeApplicationUser()
{
Id = employeeViewModel.ID,
UserName = employeeViewModel.UserName,
Position = employeeViewModel.Position
};
iEmployeeRepository.UpdateEmployee(employee);
iUnitOfWork.Save();
return(Ok(employee));
}
else
{
return(NotFound("Employee with ID " + id.ToString() + " was not found."));
}
}
public async Task <IActionResult> OnGetAsync(int employeeId)
{
EmployeeDetailsViewModel employeeDetailsViewModel = await _employeeService.GetEmployeeDetailsAsync(employeeId);
if (employeeDetailsViewModel == null)
{
return(NotFound());
}
UpdateEmployeeViewModel = new UpdateEmployeeViewModel()
{
EmployeeId = employeeDetailsViewModel.EmployeeId,
EmployeeName = employeeDetailsViewModel.EmployeeName,
DepartmentId = employeeDetailsViewModel.DepartmentId,
DateOfBirth = employeeDetailsViewModel.DateOfBirth,
Email = employeeDetailsViewModel.Email,
PhoneNumber = employeeDetailsViewModel.PhoneNumber
};
SelectList items = await _departmentService.GetDepartmentSelectListAsync(employeeDetailsViewModel.DepartmentId);
DepartmentSelectList = items;
return(Page());
}
public IActionResult Update(UpdateEmployeeViewModel model)
{
{
if (ModelState.IsValid)
{
{
Employee TheEmployee = context.Employees.Find(model.Id);
TheEmployee.Name = model.Name;
TheEmployee.Skill = model.Skill;
TheEmployee.Hobby = model.Hobby;
TheEmployee.Type = model.Type;
context.Employees.Update(TheEmployee);
context.SaveChanges();
return(Redirect("/Employees"));
/*Name = UpdateEmployeeViewModel.Name,
* Skill = UpdateEmployeeViewModel.Skill,
* Hobby = UpdateEmployeeViewModel.Hobby,
* Type = UpdateEmployeeViewModel.Type*/
};
/*context.Employees.Update(TheEmployee);
* context.SaveChanges();*/
/*return Redirect("/Employees");*/
}
return(View());
}
}
public void UpdateEmployeeDetails(UpdateEmployeeViewModel uevm)
{
var config = new MapperConfiguration(cfg => { cfg.CreateMap <UpdateEmployeeViewModel, Employee>(); cfg.IgnoreUnmapped(); });
IMapper mapper = config.CreateMapper();
Employee e = mapper.Map <UpdateEmployeeViewModel, Employee>(uevm);
var result = er.UpdateEmpolyeeDetails(e);
}
public IActionResult Update([FromBody] UpdateEmployeeViewModel viewModel)
{
return(ApiAction(() =>
{
var contract = _mapper.Map <UpdateEmployeeContract>(viewModel);
_employeeService.UpdateEmployee(contract);
return Accepted();
}));
}
public async Task <IActionResult> UpdateEmployee(UpdateEmployeeViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
await _service.UpdateEmployee(_userManager, model, User, _signInManager);
return(RedirectToAction("Index"));
}
public ActionResult UpdateEmplyee(string id)
{
EmployeeViewModel evm = this.es.GetEmployeeByID(id);
UpdateEmployeeViewModel uevm = new UpdateEmployeeViewModel()
{
EmployeeId = evm.Id, EmployeeName = evm.EmployeeName, Address = evm.Address, DateOfBirth = evm.DateOfBirth, Phone = evm.Phone, Email = evm.Email
};
return(View(uevm));
}
public IActionResult Update(int id, UpdateEmployeeViewModel model)
{
var user = _userAppService.GetAdminById(id);
model = new UpdateEmployeeViewModel()
{
Id = user.Id,
UserName = user.UserName,
NickName = user.NickName,
};
return(PartialView("_Update", model));
}
public async Task UpdateEmplyeeAsync(UpdateEmployeeViewModel updateEmployeeViewModel)
{
string jsonStringBody = JsonSerializer.Serialize(updateEmployeeViewModel);
using StringContent content = new StringContent(jsonStringBody, Encoding.UTF8, "application/json");
HttpResponseMessage response = await _httpClient.PutAsync("employee/update-employee", content);
if (!response.IsSuccessStatusCode)
{
throw new ApplicationException($"{response.ReasonPhrase}: The status code is: {(int)response.StatusCode}");
}
}
public async Task <HttpResponseMessage> UpdateAsync(UpdateEmployeeViewModel updateEmployeeViewModel)
{
if (updateEmployeeViewModel == null)
{
throw new ArgumentNullException(nameof(updateEmployeeViewModel));
}
HttpResponseMessage response = await _httpClient
.PutAsJsonAsync($"v1/employees/{updateEmployeeViewModel.EmployeeId}", updateEmployeeViewModel);
return(response);
}
public static Employee MapToEmployee(UpdateEmployeeViewModel employee)
{
return(new Employee()
{
Name = employee.Name,
Title = employee.Title,
Salary = employee.Salary,
Email = employee.Email,
BirthDate = employee.BirthDate,
Photo = employee.Photo,
CountryID = employee.CountryID,
});
}
public async Task <UpdateEmployeeViewModel> GetEmployeeById(UserManager <IdentityUser> _userManager, string id)
{
var user = await _userManager.FindByIdAsync(id);
var model = new UpdateEmployeeViewModel
{
Id = user.Id,
EmailAddress = user.UserName,
Role = _userManager.IsInRoleAsync(user, "Admin").Result ? "Admin" : "Cashier"
};
return(model);
}
public ActionResult UpdateEmployee(UpdateEmployeeViewModel uevm)
{
if (ModelState.IsValid)
{
this.es.UpdateEmployeeDetails(uevm);
return(RedirectToAction("Profile", "Account"));
}
else
{
ModelState.AddModelError("x", "Invalid data");
return(View(uevm));
}
}
public ViewResult Update(int id)
{
Employee employee = context.Employees.Find(id);
UpdateEmployeeViewModel updateEmployeeViewModel = new UpdateEmployeeViewModel
{
Id = employee.Id,
Name = employee.Name,
Skill = employee.Skill,
Hobby = employee.Hobby,
Type = employee.Type
};
return(View(updateEmployeeViewModel));
}
public async Task <IActionResult> UpdateConfirmed(UpdateEmployeeViewModel vm)
{
if (ModelState.IsValid)
{
if (vm.IdEmployee == null)
{
return(NotFound());
}
var result = await _employeeService.UpdateMainInfoEmployeeAsync(_mapper.Map <GeneralInfoEmployeeDTO>(vm));
return(result.IsValid
? RedirectToAction("Index")
: _oops.OutPutError("Employee", "Index", result.ErrorsList));
}
return(View(vm));
}
public async Task <ActionResult> Edit(int id, UpdateEmployeeViewModel updateEmployee)
{
try
{
var employee = Mapper.MapToEmployee(updateEmployee);
employee.Id = id;
_uow.EmployeeRepository.UpdateEmployee(employee);
await _uow.Save();
return(RedirectToAction(nameof(Index)));
}
catch
{
return(View());
}
}
public async Task <IActionResult> Update(UpdateEmployeeViewModel model)
{
var employeeToUpdate = new UpdateEmployeeDto
{
Gender = model.Gender,
Status = model.Status,
BirthDate = model.BirthDate,
LastName = model.LastName,
PersonalId = model.PersonalId,
JobPosition = model.JobPosition,
FireDate = model.FireDate,
FirstName = model.FirstName,
IsDeleted = model.IsDeleted
};
await _clientWrapper.PutAsync <UpdateEmployeeDto>($"api/Employees/{model.Id}", employeeToUpdate);
return(RedirectToAction("Index"));
}
public IActionResult Update(UpdateEmployeeViewModel model)
{
var user = new UserModel()
{
Id = model.Id,
NickName = model.NickName,
};
user = _userAppService.UpdateBasicInfo(user);
return(Json(new JsonResultEntity()
{
Message = "编辑信息成功！",
JsonObject = Json(new EmployeeViewModel()
{
Id = user.Id,
NickName = user.NickName,
LastModificationTime = user.LastModificationTime?.ToStandardDateOfChina()
})
}));
}
protected override async Task OnInitializedAsync()
{
EmployeeDetailsViewModel employeeDetailsViewModel = await _employeeService.GetDetailsByIdAsync(EmployeeId);
if (employeeDetailsViewModel == null)
{
ErrorMessage = "Employee with provided id does not exists!";
}
UpdateEmployeeModel = new UpdateEmployeeViewModel()
{
EmployeeId = employeeDetailsViewModel.EmployeeId,
EmployeeName = employeeDetailsViewModel.EmployeeName,
DepartmentId = employeeDetailsViewModel.DepartmentId,
DateOfBirth = employeeDetailsViewModel.DateOfBirth,
Email = employeeDetailsViewModel.Email,
PhoneNumber = employeeDetailsViewModel.PhoneNumber
};
DepartmentSelectList = await _departmentService.GetSelectListAsync(employeeDetailsViewModel.DepartmentId);
}
public async Task <IActionResult> UpdateConfirmed(UpdateEmployeeViewModel vm)
{
if (ModelState.IsValid)
{
if (vm.HashIdEmployee == null)
{
return(NotFound());
}
var result = await _employeeService.UpdateMainInfoEmployeeAsync(_mapper.Map <GeneralInfoEmployeeDTO>(vm));
if (result.IsValid)
{
await _systemAuditService.AuditAsync(User.GetEmail(), _accessor.GetIp(), Operations.Update, Tables.Employee);
return(RedirectToAction("Index", "Employee", new { id = vm.HashIdEmployee }));
}
TempData["ErrorsListConfirmed"] = result.ErrorsList;
}
await FillingStudyDropDownLists();
await FillingScientificDropDownLists();
vm.Sex = ConvertToUkraineGender(vm.Sex);
return(View(vm));
}
