public async Task <ActionResult> Save(EditEmployeeModel employee)
{
using (var service = new ExampleServiceClient())
{
if (this.ModelState.IsValid)
{
var dto = new EmployeeDTO
{
Id = employee.Id,
FirstName = employee.FirstName,
LastName = employee.LastName,
MiddleName = employee.MiddleName
};
await service.SaveEmployeeAsync(dto, service.GetDepartmentById(employee.DepartmentId));
return(this.RedirectToAction("EmployeeList", "Departments", new { departmentId = employee.CurrentDepartmentId }));
}
var availableDepartmentsDTO = await service.GetDepartmentsAsync();
employee.AvailableDepartments = availableDepartmentsDTO.Select(x => new Department().MapFrom(x)).ToArray();
return(this.View("Employee", employee));
}
}
public ResponseModel EditEmployee(EditEmployeeModel model)
{
ResponseModel resp = new ResponseModel();
try
{
var validateEmployee = new EditEmployeeModelValidator().Validate(model);
if (validateEmployee.IsValid)
{
var employee = _employeeRepository.GetEmployeeByUserId(Guid.Parse(model.UsuarioId));
if (employee != null)
{
EditUserModel editUserModel = new EditUserModel
{
UsuarioId = model.UsuarioId,
Name = model.Name,
Locations = model.Locations,
PhoneNumbers = model.PhoneNumbers,
Imagem = model.Imagem
};
var userResponse = _userService.EditUserFromModel(editUserModel);
if (userResponse.Success)
{
User employeeUser = userResponse.Result as User;
employee.RG = model.RG;
employee.IsManager = model.IsManager;
employee.Descricao = model.Descricao;
employee.LastUpdatedAt = DateTimeUtil.UtcToBrasilia();
employee.UpdatedBy = employeeUser.UserId;
employee.User = employeeUser;
_employeeRepository.Edit(employee);
resp.Success = true;
resp.Message = "Funcionário editado com sucesso";
}
else
{
resp = userResponse;
}
}
else
{
resp.Message = "Cliente não encontrado";
}
}
else
{
resp.Message = validateEmployee.Errors.FirstOrDefault().ErrorMessage;
}
}
catch (Exception e)
{
resp.Message = "Não foi possível editar o funcionário";
}
return(resp);
}
public void EditEmployee(EditEmployeeModel editEmpModel)
{
Employee employee = new Employee();
employee.ID = editEmpModel.Id;
employee.Name = editEmpModel.EmployeeName;
employee.Age = editEmpModel.Age;
employee.DateOfJoining = editEmpModel.DateOfJoining;
employee.Salary = editEmpModel.Salary;
employee.Comm = editEmpModel.Comm;
employee.Department = editEmpModel.DepartmentId;
_repo.UpdateEmployee(employee);
}
private void MapEmployee(Employee source, EditEmployeeModel des)
{
des.DepartmentId = source.DepartmentId;
des.DateOfBrith = source.DateOfBrith;
des.Department = source.Department;
des.EmployeeId = source.EmployeeId;
des.Gender = source.Gender;
des.LastName = source.LastName;
des.FirstName = source.FirstName;
des.PhotoPath = source.PhotoPath;
des.Email = source.Email;
des.ConfirmEmail = source.Email;
}
public ActionResult Edit(Guid id)
{
EditEmployeeModel editEmployeeModel = new EditEmployeeModel();
BusinessModels.Employee employee = _empService.GetEmployeeById(id);
editEmployeeModel.Id = employee.ID;
editEmployeeModel.EmployeeName = employee.Name;
editEmployeeModel.Age = employee.Age;
editEmployeeModel.DateOfJoining = employee.DateOfJoining;
editEmployeeModel.Salary = employee.Salary;
editEmployeeModel.Comm = employee.Comm;
editEmployeeModel.DepartmentId = employee.Department;
return(View(editEmployeeModel));
}
public ActionResult EditEmployee([FromForm] EditEmployeeModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
var result = _employeeService.EditEmployee(model);
return(Ok(result));
}
catch (ArgumentException e)
{
return(StatusCode((int)HttpStatusCode.InternalServerError, e.Message));
}
}
protected override async Task OnInitializedAsync()
{
var authState = await AuthStateTask;
if (!authState.User.Identity.IsAuthenticated)
{
string returnUrl = WebUtility.UrlEncode($"/employee/new");
NavigationManager.NavigateTo($"/identity/account/login?returnUrl={returnUrl}");
}
EditEmployeeModel = new EditEmployeeModel
{
DateOfBirth = DateTime.Now,
DepartmentId = 1,
Photo = "images/empty.png"
};
Departments = (await DepartmentService.GetAllAsync()).ToList();
}
public async Task <ActionResult> Employee(Guid?employeeId, Guid departmentId)
{
using (var service = new ExampleServiceClient())
{
var employee = employeeId.HasValue ? new Employee().MapFrom(await service.GetEmployeeAsync(employeeId.Value)) : null;
var model = new EditEmployeeModel
{
Id = employeeId ?? Guid.Empty,
FirstName = employee?.FirstName,
LastName = employee?.LastName,
MiddleName = employee?.MiddleName,
DepartmentId = departmentId,
AvailableDepartments = service.GetDepartments().Select(x => new Department().MapFrom(x)).ToArray(),
CurrentDepartmentId = departmentId
};
return(this.View(model));
}
}
public async Task <IActionResult> Edit(EditEmployeeModel editEmployeeModel)
{
var employeeUser = await userManager.FindByIdAsync(editEmployeeModel.EmployeeUser.Id);
var employee = editEmployeeModel.Employee;
if (!employee.EmployeeId.ToString().Equals(employeeUser.UserName))
{
return(View(editEmployeeModel));
}
if (!string.IsNullOrEmpty(editEmployeeModel.Password))
{
var validPass = await passwordValidator.ValidateAsync(userManager, employeeUser, editEmployeeModel.Password);
if (validPass.Succeeded)
{
employeeUser.PasswordHash =
passwordHasher.HashPassword(employeeUser, editEmployeeModel.Password);
}
else
{
AddErrorsFromResult(validPass);
}
}
repository.EditEmployee(employee);
IdentityResult result = await userManager.UpdateAsync(employeeUser);
if (result.Succeeded)
{
return(View("Index", new ViewEmployeesModel
{
EmployeeUsers = userManager.Users,
Employees = repository.Employees
}));
}
AddErrorsFromResult(result);
return(View(editEmployeeModel));
}
public async Task <IActionResult> EditEmployee(int id, EditEmployeeModel model)
{
if (ModelState.IsValid)
{
var token = HttpContext.Session.GetString("token");
var client = new HttpClient();
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);
var stringContent =
new StringContent(JsonConvert.SerializeObject(model), Encoding.UTF8, "application/json");
var response =
await client.PutAsync($"{_config["BaseApiUrl"]}api/Employees/update/{id}", stringContent);
if (response.IsSuccessStatusCode)
{
return(RedirectToAction(nameof(Details), new { id = id }));
}
}
ModelState.AddModelError(string.Empty, "invalid update attempt");
return(View(model));
}
public ActionResult Edit(EditEmployeeModel editEmployeeModel)
{
_empService.EditEmployee(editEmployeeModel);
return(RedirectToAction("Index", "Department"));
}
public ActionResult EditEmployee(EditEmployeeModel model)
{
// check if any of the dependents are not containign a first or last name.
if (model.Dependents != null && model.Dependents.Any(x => string.IsNullOrEmpty(x.DependentFirstName) || string.IsNullOrEmpty(x.DependentLastName)))
{
ModelState.AddModelError("", "Depedents First and Last name are required.");
}
if (ModelState.IsValid)
{
Employee employee = EmployeeRepository.GetById(model.Id);
employee.FirstName = model.FirstName;
employee.LastName = model.LastName;
employee.StateId = model.StateId.Value;
employee.Email = model.Email;
employee.BenefitSettingId = model.SelectedBenefitSettingId;
if (model.Dependents != null && model.Dependents.Any())
{
DependentRepository.Delete(DependentRepository.GetByEmployeeId(employee.Id).Where(x => model.Dependents.All(m => m.DependentId != x.Id)));
foreach (var dependent in model.Dependents)
{
Dependent dependentEntity = DependentRepository.GetById(dependent.DependentId);
if (dependentEntity != null)
{
dependentEntity.FirstName = dependent.DependentFirstName;
dependentEntity.LastName = dependent.DependentLastName;
DependentRepository.Update(dependentEntity);
}
else
{
employee.Dependents.Add(new Dependent
{
EmployeeId = model.Id,
FirstName = dependent.DependentFirstName,
LastName = dependent.DependentLastName
});
}
}
}
else
{
DependentRepository.Delete(DependentRepository.GetByEmployeeId(employee.Id));
}
employee = EmployeeRepository.Update(employee);
return(Json(new PostResultModel
{
IsSuccess = true,
Message = "Employee Updated",
ItemId = employee.Id,
Html = PartialView("EmployeeRow", new EmployeeRowModel(employee)).RenderToString()
}));
}
model.Populate(StateRepository.GetAll(), BenefitSettingsRepository.GetPublic());
return(PartialView(model));
}
