public async Task <IActionResult> UpdateAsync([FromBody] UpdateEmployeeDto request)
{
Logger.LogInformation($"Calling api Update Employee with Json : {JsonConvert.SerializeObject(request)}");
await _employeeService.UpdateAsync(request);
Logger.LogInformation("Updated successfully.");
return(Ok(await Result.SuccessAsync("Updated successfully.")));
}
public async Task <IActionResult> Update(UpdateEmployeeDto item)
{
if (!ModelState.IsValid)
{
return(BadRequest(new ModelStateResult(ModelState)));
}
var updateEmployeeResultDto = await _employeesService.Update(item, UserId);
return(Ok(updateEmployeeResultDto));
}
public async Task <IActionResult> UpdateEmployee([FromBody] UpdateEmployeeDto updateEmployee)
{
var response = await _employeeService.Update(updateEmployee);
if (response.Data == null)
{
return(NotFound(response));
}
return(Ok(response));
}
public async Task <IActionResult> Put(int id, [FromBody] UpdateEmployeeDto emplyeeDto)
{
var result = await _employeeService.Update(id, emplyeeDto);
if (!_employeeService.Success())
{
return(BadRequest(_employeeService.Errors));
}
return(Ok(result));
}
public void Update(UpdateEmployeeDto Dto)
{
var Employee = _DB.Employees.SingleOrDefault(x => x.Id == Dto.Id && !x.IsDelete);
Employee.Name = Dto.Name;
Employee.Phone = Dto.Phone;
Employee.Address = Dto.Address;
Employee.Salary = Dto.Salary;
Employee.EmploymentDate = Dto.EmploymentDate;
_DB.Employees.Update(Employee);
_DB.SaveChanges();
}
public async Task <IActionResult> Put(int id, [FromBody] UpdateEmployeeDto item)
{
if (item == null || item.Id != id)
{
return(BadRequest());
}
try
{
var target = _context.Employees.FirstOrDefault(e => e.Id == id);
if (target == null)
{
return(NotFound());
}
var targetContact = _context.Contacts.FirstOrDefault(c => c.Id == target.ContactId);
targetContact.FirstName = item.FirstName;
targetContact.LastName = item.LastName;
targetContact.Phone = item.Phone;
targetContact.MobilePhone = item.MobilePhone;
targetContact.Email = item.Email;
targetContact.OfficialEmail = item.OfficialEmail;
targetContact.PhysicalStreet = item.Street;
targetContact.PhysicalState = item.State;
targetContact.PhysicalCity = item.City;
targetContact.PhysicalZipCode = item.ZipCode;
targetContact.PhysicalCountry = item.Country;
target.EmployeeTypeId = item.EmployeeTypeId;
target.EmployeeStatusId = item.EmployeeStatusId;
target.DesignationId = item.DesignationId;
target.IsUnderProbation = item.IsUnderProbation;
target.EndedProbationAt = item.EndedProbationAt;
target.HiredAt = item.HiredAt;
target.LeaveAt = item.LeaveAt;
target.ABAAccountName = item.ABAAccountName;
target.ABAAccountNumber = item.ABAAccountNumber;
target.Remarks = item.Remarks;
_context.Update(targetContact);
_context.Update(target);
await _context.SaveChangesAsync();
return(Ok());
} catch (Exception e)
{
_logger.LogError("API_ERR | PUT_EMPLOYEE | item: {0} | ERR: {1}", JsonConvert.SerializeObject(item), e.StackTrace.ToString());
return(StatusCode(StatusCodes.Status500InternalServerError));
}
}
private async Task InitialForm()
{
var isValid = Int32.TryParse(Id, out var id);
if (!isValid)
{
_navigationManager.NavigateTo("/exception/404");
}
var response = await _employeeManager.GetByIdAsync(id);
if (response.Succeeded)
{
var item = response.Data;
_employeeModel = new UpdateEmployeeDto
{
Id = item.Id,
EmployeeIdNumber = item.EmployeeIdNumber,
Phone = item.Phone,
AccountNumber = item.AccountNumber,
Email = item.Email,
AccountTitle = item.AccountTitle,
Address1 = item.Address1,
Address2 = item.Address2,
BankName = item.BankName,
BasicSalary = item.BasicSalary,
City = item.City,
Country = item.Country,
DateOfBirth = item.DateOfBirth,
DepartmentId = item.DepartmentId,
FirstName = item.FirstName,
LastName = item.LastName,
Gender = item.Gender,
JoiningDate = item.JoiningDate,
LeavingDate = item.LeavingDate,
MaritalStatus = item.MaritalStatus,
PlaceOfBirth = item.PlaceOfBirth,
StateProvince = item.StateProvince,
UnpaidLeavePerDay = item.UnpaidLeavePerDay,
SupervisorId = item.SupervisorId,
SystemUserId = item.SystemUserId,
ZipCode = item.ZipCode
};
}
else
{
foreach (var message in response.Messages)
{
await _message.Error(message);
}
}
}
public async Task <ActionResult> Update(int id, [FromBody] UpdateEmployeeDto model)
{
var employee = await _employeeDao.GetByIdAsync(id);
if (employee is null)
{
return(NotFound($"Employee with id { id} not found"));
}
await _employeeDao.UpdateAsync(model.GetEmployee(id));
return(Ok());
}
public async Task <UpdateEmployeeDto> UpdateEmployee(UpdateEmployeeDto employee, Guid employeeId)
{
var e = await _employeetRepository.FirstOrDefaultAsync(employeeId);
if (e == null)
{
throw new UserFriendlyException("This employee does not exist");
}
var id = e.Id;
ObjectMapper.Map(employee, e);
e.Id = id;
return(ObjectMapper.Map <UpdateEmployeeDto>(await _employeeManager.UpdateEmployeeAsync(e)));
}
public async Task UpdateEmployeeAsync_should_update_employee_when_using_valid_jwt()
{
// Arrange
using (var server = this.GetServer())
using (var client = this.GetClient(server))
{
// Create the employee and get a jwt.
var model = new CreateEmployeeDto
{
EmployeeCardId = Guid.NewGuid().ToString(),
Email = "*****@*****.**",
MobileNumber = "0123456789",
EmployeeId = Guid.NewGuid().ToString(),
Name = "Integration Test",
Pin = "1234"
};
var json = JsonConvert.SerializeObject(model);
var body = new StringContent(json, Encoding.UTF8, "application/json");
var response = await client.PostAsync("/api/employees", body);
response.EnsureSuccessStatusCode();
var jwt = JsonConvert.DeserializeObject <String>(await response.Content.ReadAsStringAsync());
// Create the update definition.
var updateModel = new UpdateEmployeeDto
{
Email = "*****@*****.**",
MobileNumber = "0123456789",
EmployeeId = Guid.NewGuid().ToString(),
Name = "Integration Test",
};
var updateJson = JsonConvert.SerializeObject(model);
var updateBody = new StringContent(json, Encoding.UTF8, "application/json");
// Add the jwt to the authorization header.
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", jwt);
// Act
var updateResponse = await client.PutAsync("/api/employees", updateBody);
response.EnsureSuccessStatusCode();
var responseString = await updateResponse.Content.ReadAsStringAsync();
// Assert
var result = Boolean.Parse(responseString);
Assert.True(result);
}
}
[HttpPatch("update/employeePI/{employeeId:int}", Name = "UpdateEmployeePI")] //Update employee info
public IActionResult UpdateEmployeePI(int employeeId, [FromBody] UpdateEmployeeDto updateEmployeeDto)
{
if (updateEmployeeDto == null || employeeId != updateEmployeeDto.Id)
{
return(BadRequest(ModelState));
}
var employeeObj = _mapper.Map <EmployeePI>(updateEmployeeDto);
if (!_npRepo.UpdateEmployeePI(employeeObj))
{
ModelState.AddModelError("", $"Something went wrong when updating the record {employeeObj.Id}");
return(StatusCode(500, ModelState));
}
return(NoContent());
}
public async Task <IActionResult> UpdateEmployeeAsync([FromBody] UpdateEmployeeDto model)
{
try
{
// Update the employee using the employeeCardId from the auth token.
var updated = await this.EmployeeRepository.UpdateEmployeeAsync(this.EmployeeCardId, model);
// Return the result of the update.
return(this.Ok(updated));
}
catch (Exception ex)
{
this.Logger.LogError(ex, "Error when UpdateEmployeeAsync for employeeCardId {0}", this.EmployeeCardId);
return(this.StatusCode(500));
}
}
public async Task <IActionResult> UpdateEmployee(Guid id, [FromBody] UpdateEmployeeDto model,
[FromQuery] string fields)
{
try
{
if (!await _manager.UpdateEmployee(id, model, fields))
{
return(Ok(new JsonMessageResult("修改失败！", 0, 0)));
}
return(NoContent());
}
catch (Exception e)
{
_logger.LogError(e, e.Message);
return(Ok(new JsonMessageResult(e.Message, 0, 0)));
}
}
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 async Task Update(int id, UpdateEmployeeDto updateData)
{
if (updateData == null)
{
throw new ArgumentNullException(nameof(updateData));
}
var employeeToUpdate = await _repository.GetById(id);
if (employeeToUpdate == null)
{
throw new InvalidOperationException();
}
if (updateData.FreeWorkDays != employeeToUpdate.FreeWorkDays)
{
employeeToUpdate.FreeWorkDays = updateData.FreeWorkDays;
}
if (updateData.Email != employeeToUpdate.Email)
{
// email has changed so check if the new email is already taken
if (_repository.FindByEmail(updateData.Email).Result != null)
{
throw new Exception("Email " + updateData.Email + " is already taken");
}
await _userService.ChangeEmail(id, updateData.Email);
}
var parentalLeaveDifference = updateData.ParentalLeaveLimit - employeeToUpdate.ParentalLeaveLimit;
employeeToUpdate.CurrentAvailableLeaves = Math.Max(employeeToUpdate.CurrentAvailableLeaves + parentalLeaveDifference, 0);
employeeToUpdate.NextMonthAvailableLeaves = Math.Max(employeeToUpdate.NextMonthAvailableLeaves + parentalLeaveDifference, 0);
_mapper.Map(updateData, employeeToUpdate);
await _repository.Update(employeeToUpdate);
await _userService.Update(id, updateData);
}
public async Task UpdateEmployeeAsync_should_return_500_when_error()
{
// Arrange
var controller = new EmployeesController(null, null, this.Logger)
{
EmployeeCardId = this.Fixture.ValidId
};
var contextMock = new Mock <HttpContext>();
contextMock.Setup(x => x.User).Returns(new ClaimsPrincipal());
controller.ControllerContext.HttpContext = contextMock.Object;
var model = new UpdateEmployeeDto();
// Act
var response = await controller.UpdateEmployeeAsync(model);
// Assert
var result = Assert.IsType <StatusCodeResult>(response);
Assert.Equal(500, result.StatusCode);
}
public async Task UpdateEmployeeAsync_should_return_200_with_false_when_not_updated()
{
// Arrange
var controller = new EmployeesController(this.Fixture.EmployeeRepository, this.Fixture.JwtRepository, this.Logger)
{
EmployeeCardId = this.Fixture.InvalidId
};
var contextMock = new Mock <HttpContext>();
contextMock.Setup(x => x.User).Returns(new ClaimsPrincipal());
controller.ControllerContext.HttpContext = contextMock.Object;
var model = new UpdateEmployeeDto();
// Act
var response = await controller.UpdateEmployeeAsync(model);
// Assert
var result = Assert.IsType <OkObjectResult>(response);
var resultValue = Boolean.Parse(result.Value.ToString());
Assert.False(resultValue);
}
public async Task <UpdateEmployeeResultDto> Update(UpdateEmployeeDto updateEmployeeDto, int userId)
{
var employee = await _employeesRepository.GetAsync(updateEmployeeDto.Id);
if (employee == null)
{
throw new ValidationException(Messages.EmployeeDoesNotExist, nameof(Messages.EmployeeDoesNotExist));
}
var company = await _companiesRepository.GetAsync(employee.CompanyId, userId);
if (company == null)
{
throw new ValidationException(Messages.EmployeeDoesNotExist, nameof(Messages.EmployeeDoesNotExist));
}
employee.Position = updateEmployeeDto.Position;
await _employeesRepository.UpdateAsync(employee);
return(new UpdateEmployeeResultDto());
}
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 <ValidationResult> UpdateValidate(int employeeId, UpdateEmployeeDto employeeDto)
{
if (employeeId != employeeDto.Id)
{
return(new ValidationResult(new List <ValidationFailure> {
new ValidationFailure("Error", "Identification is invalid.")
}));
}
var validations = Validate(employeeDto);
if (!validations.IsValid)
{
return(validations);
}
var query = await _employeeRepository.Get();
if (query.Any(employee => employee.Name.IsEquals(employeeDto.Name) && employee.Id != employeeId))
{
validations.Errors.Add(new ValidationFailure("Error", "Name must be unique."));
}
if (query.Any(employee => employee.Cpf.IsEquals(employeeDto.Cpf.OnlyNumbers()) && employee.Id != employeeId))
{
validations.Errors.Add(new ValidationFailure("Error", "CPF must be unique."));
}
if (employeeDto.CompanyId > 0 && employeeDto.Hiring.IsEmpty())
{
validations.Errors.Add(new ValidationFailure("Error", "Hiring is required."));
}
if (employeeDto.RoleId > 0 && (!employeeDto.CompanyId.HasValue || employeeDto.CompanyId == 0))
{
validations.Errors.Add(new ValidationFailure("Error", "CompanyId is required."));
}
return(validations);
}
public async Task UpdateEmployeeAsync_should_be_protected()
{
// Arrange
using (var server = this.GetServer())
using (var client = this.GetClient(server))
{
var model = new UpdateEmployeeDto
{
Email = "*****@*****.**",
MobileNumber = "0123456789",
EmployeeId = Guid.NewGuid().ToString(),
Name = "Integration Test",
};
var json = JsonConvert.SerializeObject(model);
var body = new StringContent(json, Encoding.UTF8, "application/json");
// Act
var response = await client.PutAsync("/api/employees", body);
// Assert
Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode);
}
}
public async Task <int> UpdateAsync(UpdateEmployeeDto request)
{
Require.IsNotNull(request);
try
{
var editEmployee = await _employeeRepository.FirstOrDefaultAsync(x => x.Id.Equals(request.Id));
if (editEmployee == null)
{
throw new ValidationException($"Error : Id {request.Id} does not exist");
}
//duplicate Employee Number ID is not allowed
Employee empNumber = await _employeeRepository.FirstOrDefaultAsync(x => x.EmployeeIdNumber.Equals(request.EmployeeIdNumber), disableTracking : true);
if (empNumber != null && editEmployee.EmployeeIdNumber != request.EmployeeIdNumber && !String.IsNullOrEmpty(request.EmployeeIdNumber))
{
throw new ValidationException($"Error: Employee Id Number - {request.EmployeeIdNumber} Can Not Duplicate.");
}
//duplicate System user account is not allowed
Employee empSystem = await _employeeRepository.FirstOrDefaultAsync(x => x.SystemUserId.Equals(request.SystemUserId), disableTracking : true);
if (empSystem != null && editEmployee.SystemUserId != request.SystemUserId && !String.IsNullOrEmpty(request.SystemUserId))
{
throw new ValidationException("Error: Application System User Account Already Been Used. " + request.SystemUserId);
}
editEmployee.FirstName = request.FirstName;
editEmployee.LastName = request.LastName;
editEmployee.Gender = request.Gender;
editEmployee.DateOfBirth = request.DateOfBirth;
editEmployee.PlaceOfBirth = request.PlaceOfBirth;
editEmployee.MaritalStatus = request.MaritalStatus;
editEmployee.Email = request.Email;
editEmployee.Phone = request.Phone;
editEmployee.Address1 = request.Address1;
editEmployee.Address2 = request.Address2;
editEmployee.City = request.City;
editEmployee.StateProvince = request.StateProvince;
editEmployee.ZipCode = request.ZipCode;
editEmployee.Country = request.Country;
editEmployee.EmployeeIdNumber = request.EmployeeIdNumber;
editEmployee.DepartmentId = request.DepartmentId;
editEmployee.JoiningDate = request.JoiningDate;
editEmployee.LeavingDate = request.LeavingDate;
editEmployee.SupervisorId = request.SupervisorId;
editEmployee.BasicSalary = request.BasicSalary;
editEmployee.UnpaidLeavePerDay = request.UnpaidLeavePerDay;
editEmployee.AccountTitle = request.AccountTitle;
editEmployee.BankName = request.BankName;
editEmployee.AccountNumber = request.AccountNumber;
editEmployee.SystemUserId = request.SystemUserId;
_employeeRepository.Update(editEmployee);
return(await _unitOfWork.SaveChangesAsync());
}
catch (Exception ex)
{
_logger.LogError(ex, "Error when calling EmployeeService.UpdateAsync");
throw;
}
}
public async Task <IActionResult> UpdateEmployeeForCompany(Guid companyId, Guid id, [FromBody] UpdateEmployeeDto employee)
{
var employeeEntity = HttpContext.Items["employee"] as Employee;
_mapper.Map(employee, employeeEntity);
await _repositoryManager.SaveAsync();
return(NoContent());
}
public async Task <IResult> UpdateAsync(UpdateEmployeeDto request)
{
var response = await _httpClient.PutAsJsonAsync(Routes.EmployeeEndpoint.Update, request);
return(await response.ToResult());
}
public async Task <ActionResult <EmployeeDto> > UpdateEmployeeForCompany(Guid companyId, Guid employeeId, UpdateEmployeeDto updateEmployeeDto)
{
if (!await _companyRepository.CompanyExistsAsync(companyId))
{
return(NotFound());
}
var employeeEntity = await _companyRepository.GetEmployeeAsync(companyId, employeeId);
if (employeeEntity == null)
{
var employeeToAddEntity = _mapper.Map <Employee>(updateEmployeeDto);
employeeToAddEntity.id = employeeId;
_companyRepository.AddEmployee(companyId, employeeToAddEntity);
await _companyRepository.SaveAysnc();
var returnDto = _mapper.Map <EmployeeDto>(employeeToAddEntity);
return(CreatedAtRoute(nameof(GetEmployeeForCompany), new { companyId = companyId, employeeId = returnDto.id }, returnDto));
}
_mapper.Map(updateEmployeeDto, employeeEntity);
_companyRepository.UpdateEmployee(employeeEntity);
await _companyRepository.SaveAysnc();
return(NoContent());
}
public ActionResult <EmployeeDto> Put([FromRoute] int id, [FromBody] UpdateEmployeeDto employee)
{
return(_employeeService.UpdateEmployee(id, employee));
}
// Put: EmployeeController/Update
public IActionResult Update([FromBody] UpdateEmployeeDto dTO)
{
_EmployeeService.Update(dTO);
return(Ok(GetRespons()));
}
public Task <ServiceResponse <GetEmployeeDto> > UpdateSalary(UpdateEmployeeDto employee)
{
throw new NotImplementedException();
}
public async Task <IActionResult> Put(int id, [FromBody] UpdateEmployeeDto updateEmployeeDto)
{
await _employeesService.Update(id, updateEmployeeDto);
return(NoContent());
}
