public async Task <Response <bool> > UpdateEmployeeAsync(UpdateEmployeeRequest request)
{
var user = await _userManager.FindByIdAsync(request.Id);
if (user is null)
{
throw new ApiException("User does not exist.");
}
user.FirstName = request.FirstName;
user.LastName = request.LastName;
user.PhoneNumber = request.PhoneNumber;
user.DateOfBirth = request.DateOfBirth;
user.Email = request.Email;
await _userManager.UpdateAsync(user);
var allPermissions = _applicationDbContext.Set <UserPermission>().Where(x => x.UserId == user.Id).ToList();
foreach (var permission in allPermissions)
{
var updatedPermission = request.Permissions.FirstOrDefault(x => x.PermissionId == permission.PermissionId);
if (updatedPermission != null)
{
permission.Enabled = updatedPermission.Enabled;
}
}
_applicationDbContext.SaveChanges();
return(new Response <bool>(true));
}
public async Task <StatusData <string> > UpdateEmployment(UpdateEmployeeRequest request, SystemSession session)
{
var serviceRequest = new Employment
{
Mode = (byte)SystemDbStatus.Updated,
City = new City {
CityId = request.CityId
},
PersonEmploymentId = request.PersonEmploymentId,
// RequestId = request.RequestId != 0 ? request.RequestId : 0,
UserId = session.UserId,
EmployeeInfo = new CompanyEmployeeInfo {
CompanyId = request.CompanyId ?? 0, CompanyName = request.CompanyName, Position = request.Position, StartDate = request.StartDate.ToString(), EndDate = request.EndDate != null?request.EndDate.ToString() : null, EmployeeTypeId = (int)request.EmployeeTypeId
}
};
var response = await Task.Factory.StartNew(() => Client.UserService.upsertEmployeementHistory(serviceRequest, session.GetSession())).ConfigureAwait(false);
var result = new StatusData <string> {
Status = (SystemDbStatus)response.DbStatus.DbStatusCode, Message = response.DbStatus.DbStatusMsg, SubStatus = response.DbStatus.DbSubStatusCode
};
if (!request.EndDate.HasValue && result.Status.IsOperationSuccessful())
{
var empSch = new EmployeeWorkScheduleUpdateRequest {
PersonEmploymentId = response.PersonEmploymentId, ScheduleType = request.WorkSchedule.ScheduleType, Schedules = request.WorkSchedule.Schedules
};
await UpdateEmployeeWorkSchedule(empSch, session).ConfigureAwait(false);
}
return(result);
}
public async Task <IActionResult> UpdateEmployee([FromRoute] Guid employeeId,
[FromBody] UpdateEmployeeRequest request,
CancellationToken cancellationToken)
{
var employee =
await _payrollContext.Employees.SingleOrDefaultAsync(e => e.Id == employeeId, CancellationToken.None);
if (employee == null)
{
return(NotFound());
}
employee.UpdateEmployee(request.Name, request.HolidayAllowance);
employee.BankDetails.AccountNumber = request.BankAccountNumber;
employee.BankDetails.SortCode = request.SortCode;
employee.AnnualPay = request.AnnualPay.Value;
switch (employee.ContractType)
{
case ContractType.Contractor:
var contractor = employee as Contractor;
contractor.BankDetails.AccountNumber = request.BankAccountNumber;
contractor.ContractExpires =
request.ContractExpiryDate.GetValueOrDefault(contractor.ContractExpires);
break;
}
await _payrollContext.SaveChangesAsync(cancellationToken);
return(Accepted());
}
public async Task <IActionResult> Update([FromRoute] int employeeId, [FromBody] UpdateEmployeeRequest updateEmployeeRequest)
{
var employee = new Employee
{
Id = employeeId,
FirstName = updateEmployeeRequest.FirstName,
LastName = updateEmployeeRequest.LastName,
PersonalIdentity = updateEmployeeRequest.PersonalIdentity,
ManagerId = updateEmployeeRequest.ManagerId
};
var updatedEmployee = await _repo.UpdateEmployeeAsync(employee);
if (updatedEmployee)
{
return(Ok(new EmployeeResponse
{
Id = employee.Id,
FirstName = employee.FirstName,
LastName = employee.LastName,
PersonalIdentity = employee.PersonalIdentity,
ManagerId = employee.ManagerId
}));
}
else
{
return(BadRequest(new { Error = "There was an error updating the Employee" }));
}
}
/// <inheritdoc/>
public void UpdateEmployee(UpdateEmployeeRequest request)
{
if (request.Id == Guid.Empty || string.IsNullOrEmpty(request.FirstName) || string.IsNullOrEmpty(request.LastName))
{
throw new ArgumentException();
}
_employeeRepository.UpdateEmployee(_mapper.Map <UpdateEmployeeRequest, DbEmployee>(request));
}
/// <summary>
/// Updates exist employee
/// </summary>
/// <param name="employee">Employee to update</param>
public WebEmployee UpdateEmployee(UpdateEmployeeRequest employee)
{
var dbEmployee = _dbContext.Employees.FirstOrDefault(m => m.Id == employee.Id);
if (dbEmployee == null)
{
throw new NotFoundException($"Employee with id '{employee.Id}' not exist");
}
if (!string.IsNullOrEmpty(employee.FirstName))
{
dbEmployee.FirstName = employee.FirstName;
}
if (!string.IsNullOrEmpty(employee.SecondName))
{
dbEmployee.SecondName = employee.SecondName;
}
if (!string.IsNullOrEmpty(employee.Address))
{
dbEmployee.Address = employee.Address;
}
if (employee.DepartmentId > 0)
{
var dbDepartment = _dbContext.Departments.First(d => d.Id == employee.DepartmentId);
dbEmployee.Department = dbDepartment ?? throw new NotFoundException($"Department {employee.DepartmentId} does not exist");
dbEmployee.DepartmentId = employee.DepartmentId;
}
if (employee.SalaryId > 0)
{
var dbSalaryInfo = _dbContext.Salaries.First(d => d.Id == employee.SalaryId);
dbEmployee.SalaryInfo = dbSalaryInfo ?? throw new NotFoundException($"Salary info {employee.DepartmentId} does not exist");
dbEmployee.SalaryInfoId = employee.SalaryId;
}
using (var txn = _dbContext.Database.BeginTransaction())
{
try
{
_dbContext.Employees.Update(dbEmployee);
_dbContext.SaveChanges();
txn.Commit();
}
catch
{
txn.Rollback();
throw;
}
}
return(dbEmployee.EmployeeToWebEmployee());
}
public IActionResult UpdateEmployee([FromRoute] long id, [FromBody] UpdateEmployeeRequest updateEmployee)
{
updateEmployeeValidator.ValidateAndThrow(updateEmployee);
var employeeId = employeeRepository.UpdateEmployee(id, updateEmployee);
if (employeeId == -1)
{
return(BadRequest("Employee Not Found. No Employee was updated"));
}
return(Ok(employeeId));
}
public IActionResult OnCreate(UpdateEmployeeRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var result = this.departmentService.Add(request);
return(Ok(result));
}
public async Task <IHttpActionResult> UpdateEmployee([FromUri] int id, [FromBody] UpdateEmployeeRequest updateRequest)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
await _employeeService.UpdateEmployeeAsync(id, updateRequest);
return(ResponseMessage(Request.CreateResponse(HttpStatusCode.NoContent)));
}
public async Task <IHttpActionResult> AddEmployee([FromBody] UpdateEmployeeRequest updateRequest)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var createdEmployee = await _employeeService.CreateEmployeeAsync(updateRequest);
var location = string.Format("/api/employees/{0}", createdEmployee.Id);
return(Created <Employee>(location, createdEmployee));
}
public long UpdateEmployee(long id, UpdateEmployeeRequest updateEmployee)
{
var employee = context.Employees.FirstOrDefault(x => x.Id == id);
if (employee == null)
{
return(-1);
}
employee.Name = updateEmployee.Name;
employee.LastUpdate = DateTime.Now;
context.Update(employee);
context.SaveChanges();
return(employee.Id);
}
public IActionResult Update([FromServices] IEmployeeService employeeService, UpdateEmployeeRequest request)
{
try
{
var createDto = request.MapTo <UpdateEmployeeRequest, EmployeeDto>();
var result = employeeService.Update(createDto);
return(Ok(result));
}
catch (InvalidOperationException ex)
{
return(BadRequest(ex.Message));
}
}
public virtual async Task <IHttpActionResult> UpdateAsync(UpdateEmployeeRequest request)
{
var entity = await _employeeService.FirstOrDefaultAsync(a => a.Id == request.Id);
entity.Department = request.Department;
entity.Name = request.Name;
var result = await _employeeService.UpdateAsync(entity);
if (result > 0)
{
return(Succeed("修改成功"));
}
else
{
return(Fail("修改失败"));
}
}
UpdateEmployeeRequest GetRequestInfo()
{
// Get the Json from the POST.
string strJson = String.Empty;
HttpContext context = HttpContext.Current;
context.Request.InputStream.Position = 0;
using (StreamReader inputStream = new StreamReader(context.Request.InputStream))
{
strJson = inputStream.ReadToEnd();
}
// Deserialize the Json.
UpdateEmployeeRequest req = JsonConvert.DeserializeObject <UpdateEmployeeRequest>(strJson);
return(req);
}
public ActionResult UpdateEmployee(UpdateEmployeeRequest request)
{
try
{
_employeeService.UpdateEmployee(request);
return(Ok());
}
catch (ArgumentException)
{
return(StatusCode((int)HttpStatusCode.NotAcceptable, "Id can not be null, last name and first name could not be empty"));
}
catch (Exception e)
{
_logger.LogError($"Error in UpdateEmployee: {e}");
return(StatusCode((int)HttpStatusCode.InternalServerError, e.ToString()));
}
}
public ActionResult Put([FromBody] UpdateEmployeeRequest employee)
{
if (ModelState.IsValid)
{
_service.Update(new EmployeeDTO
{
Id = employee.Id,
Name = employee.Name,
Email = employee.Email,
Department = employee.Department
});
return(Ok());
}
else
{
return(BadRequest(ModelState));
}
}
public IHttpActionResult PutEmployee(int id, UpdateEmployeeRequest employeeRequest)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var existingEmployee = _employeeService.Get(id);
if (existingEmployee == null)
{
return(NotFound());
}
existingEmployee.Name = employeeRequest.Name;
_employeeService.Update(existingEmployee);
return(StatusCode(HttpStatusCode.NoContent));
}
private async void UxUpdateEmployeeButton_Click(object sender, RoutedEventArgs e)
{
if (String.IsNullOrEmpty(uxUsernameEntry.Text) || String.IsNullOrEmpty(uxWageBox.Text) || String.IsNullOrEmpty(uxFirstNameEntry.Text) || String.IsNullOrEmpty(uxLastNameEntry.Text) || String.IsNullOrEmpty(uxPositionComboBox.SelectedItem.ToString()))
{
ContentDialog responseAlert = new ContentDialog
{
Title = "Required fields are missing",
Content = "Please make sure that all fields are filled out",
CloseButtonText = "Ok"
};
ContentDialogResult result = await responseAlert.ShowAsync();
}
else
{
var validUpdate = await UpdateEmployeeRequest.SendUpdateEmployeeRequest(selectedEmployee._id, uxWageBox.Text.ToString(), uxFirstNameEntry.Text, uxLastNameEntry.Text, uxUsernameEntry.Text, uxPositionComboBox.SelectedItem.ToString());
if (validUpdate)
{
ContentDialog responseAlert = new ContentDialog
{
Title = "Update Successful",
Content = "Employee information was updated",
CloseButtonText = "Ok"
};
ContentDialogResult result = await responseAlert.ShowAsync();
}
else
{
ContentDialog responseAlert = new ContentDialog
{
Title = "Update Unsuccessful",
Content = "Employee information was updated",
CloseButtonText = "Ok"
};
ContentDialogResult result = await responseAlert.ShowAsync();
}
}
RefreshEmployeeList();
uxEmployeeMenuPopup.IsOpen = false;
}
public async Task <IActionResult> Update([FromRoute] string employeeNumber, [FromBody] UpdateEmployeeRequest employeeRequest)
{
if (employeeNumber != null && employeeRequest != null)
{
var response = await employeeService.UpdateEmployeeAsync(employeeNumber, employeeRequest);
if (response.Success)
{
return(Ok(response.EmployeeRecord));
}
return(base.BadRequest(new EmployeeResponse
{
Errors = response.Errors
}));
}
return(base.BadRequest(new EmployeeResponse
{
Errors = new[] { "Something went wrong" }
}));;
}
public async Task <GetEmployeeResponse> UpdateEmployee(Guid id, UpdateEmployeeRequest dto)
{
var employee = await _unitOfWork.Employees.Get(id);
// validate
if (employee is null)
{
throw new KeyNotFoundException();
}
if (!string.IsNullOrEmpty(dto.FirstName) && employee.FirstName != dto.FirstName)
{
employee.FirstName = dto.FirstName;
}
if (!string.IsNullOrEmpty(dto.LastName) && employee.LastName != dto.LastName)
{
employee.LastName = dto.LastName;
}
_unitOfWork.Commit();
return(_mapper.Map <GetEmployeeResponse>(employee));
}
public IActionResult UpdateEmployee([FromBody] UpdateEmployeeRequest updateEmployeeRequest)
{
var employee = _employeeManager.UpdateEmployee(updateEmployeeRequest);
return(Ok(employee));
}
public async Task <ActionResult <GetEmployeeResponse> > UpdateEmployee(Guid id, [FromBody] UpdateEmployeeRequest dto)
{
var employee = await _employeeService.GetEmployeeById(id);
if (employee is null)
{
return(NotFound());
}
await _employeeService.UpdateEmployee(id, dto);
return(NoContent());
}
public async Task <HttpResponseMessage> UpdateEmployment([FromBody] UpdateEmployeeRequest request)
{
var response = await _profilePersonalService.UpdateEmployment(request, Request.GetSession()).ConfigureAwait(false);
return(Request.SystemResponse(response));
}
public async Task <IActionResult> UpdateEmployeeAccountAsync(UpdateEmployeeRequest request)
{
var currentUser = await _authenticatedUserService.GetCurentApplicationUser();
return(Ok(await _accountService.UpdateEmployeeAsync(request)));
}
public async Task <BaseResponse> Update([FromBody] UpdateEmployeeRequest request)
{
if (request == null)
{
return(BaseResponse.GetFail("Тело запроса пустое"));
}
var access = await CheckAccessToken(request.AccessToken, new List <ClaimsTypeEnum>() { ClaimsTypeEnum.Admin });
if (!access.IsSuccess)
{
return(access);
}
if (request.Employee == null)
{
return(BaseResponse.GetFail("Поле 'Сотрудник' в запросе пустое"));
}
var e = request.Employee;
if (!e.Id.HasValue)
{
return(BaseResponse.GetFail("Не задан Id обновляемого сотрудника"));
}
var id = e.Id.Value;
var employee = await _employeeRepository.GetByIdAsync(id);
if (employee == null)
{
return(BaseResponse.GetFail($"Сотрудник с id='{id}' не найден"));
}
if (e.Birthday.HasValue)
{
var validate = ValidateBirthday(e.Birthday.Value);
if (!validate.IsSuccess)
{
return(validate);
}
employee.Birthday = e.Birthday.Value;
}
if (e.FirstName != null)
{
var validate = ValidateNames(e.FirstName);
if (!validate.IsSuccess)
{
return(validate);
}
employee.FirstName = e.FirstName;
}
if (e.FatherName != null)
{
var validate = ValidateNames(e.FatherName);
if (!validate.IsSuccess)
{
return(validate);
}
employee.FatherName = e.FatherName;
}
if (e.LastName != null)
{
var validate = ValidateNames(e.LastName);
if (!validate.IsSuccess)
{
return(validate);
}
employee.LastName = e.LastName;
}
if (e.Phone != null)
{
employee.Phone = e.Phone;
}
if (e.PositionId.HasValue)
{
employee.PositionId = (PositionTypeEnum)e.PositionId.Value;
}
if (e.Sex.HasValue)
{
employee.Sex = (SexTypeEnum)e.Sex.Value;
}
try
{
await _employeeRepository.UpdateAsync(employee);
}
catch (Exception ex)
{
_logger.LogError(ex.Message, ex);
return(BaseResponse.GetFail("Непредвиденная ошибка при обновлении пользователя"));
}
return(new BaseResponse()
{
IsSuccess = true
});
}
public async Task <BaseResponse> Update(UpdateEmployeeRequest request)
=> await ExecutePostAsync <BaseResponse, UpdateEmployeeRequest>("api/employee/update", request);
public Task <StatusData <string> > UpdateEmployment(UpdateEmployeeRequest request,
SystemSession session)
{
return(_jUnitOfWork.ProfilePersonal.UpdateEmployment(request, session));
}
public virtual bool UpdateEmployee([Validate] UpdateEmployeeRequest request)
{
//TODO: Impliment Logic
return(true);
}
public async Task <EmployeeResponse> UpdateEmployeeAsync(string employeeNumber, UpdateEmployeeRequest employee)
{
loggerService.LogExecute("EmployeeService.UpdateEmployeeAsync", "");
var _employee = await dbContext.EmployeeRecord.SingleOrDefaultAsync(x => x.EmployeeNumber == new Guid(employeeNumber));
if (_employee == null)
{
return(new EmployeeResponse
{
Success = false,
Errors = new[] { "No Records found." }
});
}
_employee.FirstName = !string.IsNullOrEmpty(employee.FirstName) ? employee.FirstName : _employee.FirstName;
_employee.LastName = !string.IsNullOrEmpty(employee.LastName) ? employee.LastName : _employee.LastName;
_employee.Temperature = employee.Temperature == _employee.Temperature ? employee.Temperature : _employee.Temperature;
_employee.RecordDate = employee.RecordDate == _employee.RecordDate ? employee.RecordDate : _employee.RecordDate;
dbContext.EmployeeRecord.Update(_employee);
var saved = await dbContext.SaveChangesAsync();
loggerService.LogExecutionResult(saved > 0, "EmployeeService.UpdateEmployeeAsync", "updated employee", "failed updating employee");
return(new EmployeeResponse
{
Success = saved > 0,
EmployeeRecord = _employee
});
}
