public IActionResult UpdateEmployee(int id, [FromBody] EmployeeUpdateDTO employeeUpdate)
{
try
{
var existingEmployee = _employeeManager.GetById(id);
if (existingEmployee == null)
{
return(NotFound());
}
if (!ModelState.IsValid)
{
return(BadRequest());
}
var employee = _mapper.Map(employeeUpdate, existingEmployee);
bool isUpdate = _employeeManager.Update(employee);
if (isUpdate)
{
return(Ok(employee));
}
else
{
return(BadRequest());
}
}
catch (Exception ex)
{
return(BadRequest(ex));
}
}
public void UpdateEmployee(long employeeId, EmployeeUpdateDTO updateDTO)
{
using (EmployeeContext employeeContext = new EmployeeContext())
{
Employee employee = employeeContext.Employees.Find(employeeId);
employee.SetBuilding(updateDTO.BuildingName);
employee.SetDesignation(updateDTO.Designation);
employee.SetSeatNumber(updateDTO.SeatNumber);
employeeContext.SaveChanges();
}
}
public IActionResult UpdateEmployee(EmployeeUpdateDTO employee, Guid employeeID)
{
try
{
service.UpdateEmployee(employee, employeeID);
return(NoContent());
}
catch (Exception e)
{
return(NotFound());
}
}
public async Task <IActionResult> PartiallyUpdateEmployeeForCompany(
[FromRoute] Guid companyId,
[FromRoute] Guid employeeId,
[FromBody] JsonPatchDocument <EmployeeUpdateDTO> jsonPatchDocument)
{
if (!await this.companyRepository.CompanyExistAsync(companyId))
{
return(this.NotFound());
}
var employee = await this.companyRepository.GetEmployeeAsync(companyId, employeeId);
if (employee == null)
{
var employeeUpdateDTO = new EmployeeUpdateDTO();
jsonPatchDocument.ApplyTo(employeeUpdateDTO);
if (!this.TryValidateModel(employeeUpdateDTO))
{
return(this.ValidationProblem(this.ModelState));
}
employee = this.mapper.Map <Employee>(employeeUpdateDTO);
employee.Id = employeeId;
this.companyRepository.AddEmployee(companyId, employee);
await this.companyRepository.SaveAsync();
var employeeDTO = this.mapper.Map <EmployeeDTO>(employee);
return(this.CreatedAtAction(
nameof(GetEmployeeForCompany),
new { companyId = companyId, employeeId = employee.Id },
employeeDTO));
}
else
{
// 将 JasnPatchDocument 的操作应用到 DTO 对象
var employeeUpdateDTO = this.mapper.Map <EmployeeUpdateDTO>(employee);
jsonPatchDocument.ApplyTo(employeeUpdateDTO);
if (!this.TryValidateModel(employeeUpdateDTO))
{
return(this.ValidationProblem(this.ModelState));
}
this.mapper.Map(employeeUpdateDTO, employee);
this.companyRepository.UpdateEmployee(employee);
await this.companyRepository.SaveAsync();
return(this.NoContent());
}
}
public HttpResponseMessage UpdateEmployee(EmployeeUpdateDTO employee)
{
HttpResponseMessage message;
try
{
// EmployeeDataAccessLayer dal = new EmployeeDataAccessLayer();
var dynObj = new { result = _employee.UpdateEmployee(employee) };
message = Request.CreateResponse(HttpStatusCode.OK, dynObj);
}
catch (Exception ex)
{
message = Request.CreateResponse(HttpStatusCode.BadRequest, new { msgText = " Somthing wrong,try Again!" });
ErrorLog.CreateErrorMessage(ex, "Employee", "UpdateEmployee");
}
return(message);
}
public async Task <ActionResult <Employee> > Update(int id, [FromBody] EmployeeUpdateDTO employeeUpdateDTO)
{
if (id != employeeUpdateDTO.EmployeeNumber || employeeUpdateDTO == null)
{
return(BadRequest());
}
var employee = _mapper.Map <Employee>(employeeUpdateDTO);
if (!await _employeeRepository.UpdateAsync(employee))
{
ModelState.AddModelError("", "Error encountered when saving to database, try again. If problem persists contact your administrator");
return(StatusCode(500, ModelState));
}
return(NoContent());
}
public IHttpActionResult UpdateEmployee(int id, EmployeeUpdateDTO employeeUpdateDTO)
{
Employee employeeFromRepo = _unitOfWork.Employees.Get(id);
if (employeeFromRepo == null)
{
return(NotFound());
}
GlobalAutoMapper.Mapper.Map(employeeUpdateDTO, employeeFromRepo); //Update gemacht
_unitOfWork.Employees.Update(employeeFromRepo);
_unitOfWork.Complete();
var response = new HttpResponseMessage(HttpStatusCode.NoContent);
//response.ReasonPhrase = "Die Daten wurden aktualiziert";
return(ResponseMessage(response));
}
public async Task <IActionResult> Update(string id, [FromBody] EmployeeUpdateDTO employeeDTO)
{
try
{
_logger.LogInfo($"Employee Update attempted - id: {id}");
if (string.IsNullOrWhiteSpace(id.ToString()) || employeeDTO == null ||
id != employeeDTO.Id)
{
_logger.LogWarn($"Empty Request was submitted.");
return(BadRequest());
}
var isExists = await _employeeRepository.IsExists(id);
if (!isExists)
{
_logger.LogWarn($"Employee Update failed: no Employee with id: {id} was found.");
return(NotFound());
}
if (!ModelState.IsValid)
{
_logger.LogWarn($"Employee Data was Invalid.");
return(BadRequest(ModelState));
}
var employee = _mapper.Map <Employee>(employeeDTO);
var isSuccess = await _employeeRepository.Update(employee);
if (!isSuccess)
{
return(InternalError($"Update Operation failed."));
}
return(NoContent());
}
catch (Exception e)
{
return(InternalError($"{e.Message} - {e.InnerException}"));
}
}
public bool UpdateEmployee(EmployeeUpdateDTO employee)
{
bool res = false;
SqlCommand SqlCmd = new SqlCommand("spUpdateEmployee");
SqlCmd.CommandType = CommandType.StoredProcedure;
SqlCmd.Parameters.AddWithValue("@Id", employee.Id);
SqlCmd.Parameters.AddWithValue("@ReferenceId", ((employee.ReferenceId == null) ? "" : employee.ReferenceId));
//SqlCmd.Parameters.AddWithValue("@EmployeeId", ((employee.EmployeeId == null) ? "" : employee.EmployeeId));
SqlCmd.Parameters.AddWithValue("@FirstName", employee.FirstName);
SqlCmd.Parameters.AddWithValue("@SecondName", ((employee.SecondName == null) ? "" : employee.SecondName));
SqlCmd.Parameters.AddWithValue("@FatherName", employee.FatherName);
SqlCmd.Parameters.AddWithValue("@Gender", employee.Gender);
SqlCmd.Parameters.AddWithValue("@DateOfBirth", employee.DateOfBirth);
SqlCmd.Parameters.AddWithValue("@BloodGroup", employee.BloodGroup);
SqlCmd.Parameters.AddWithValue("@ContactNo", employee.ContactNo);
SqlCmd.Parameters.AddWithValue("@Email", ((employee.Email == null) ? "" : employee.Email));
SqlCmd.Parameters.AddWithValue("@CurrentAddress", employee.CurrentAddress);
SqlCmd.Parameters.AddWithValue("@PermanentAddress", employee.PermanentAddress);
SqlCmd.Parameters.AddWithValue("@NativePlace", employee.NativePlace);
SqlCmd.Parameters.AddWithValue("@MedicalExam", employee.MedicalExam);
SqlCmd.Parameters.AddWithValue("@DesignationId", employee.DesignationId);
SqlCmd.Parameters.AddWithValue("@ReportTo", employee.ReportTo);
SqlCmd.Parameters.AddWithValue("@CompanyId", employee.CompanyId);
SqlCmd.Parameters.AddWithValue("@State", employee.State);
SqlCmd.Parameters.AddWithValue("@City", employee.City);
SqlCmd.Parameters.AddWithValue("@ModifiedBy", employee.ModifiedBy);
SqlCmd.Parameters.AddWithValue("@Active", employee.Active);
int result = new DbLayer().ExecuteNonQuery(SqlCmd);
if (result != Int32.MaxValue)
{
res = true;
}
return(res);
}
public async Task <ActionResult> UpdateEmployeeForCompany(Guid companyId, Guid employeeId, EmployeeUpdateDTO employeeUpdateDTO)
{
if (!await this.companyRepository.CompanyExistAsync(companyId))
{
return(this.NotFound());
}
var employee = await this.companyRepository.GetEmployeeAsync(companyId, employeeId);
if (employee == null)
{
employee = this.mapper.Map <Employee>(employeeUpdateDTO);
employee.Id = employeeId;
this.companyRepository.AddEmployee(companyId, employee);
await this.companyRepository.SaveAsync();
var employeeDTO = this.mapper.Map <EmployeeDTO>(employee);
return(this.CreatedAtAction(
nameof(GetEmployeeForCompany),
new { companyId = companyId, employeeId = employee.Id },
employeeDTO));
}
else
{
this.mapper.Map(employeeUpdateDTO, employee);
this.companyRepository.UpdateEmployee(employee);
await this.companyRepository.SaveAsync();
return(this.NoContent());
}
}
public IActionResult UpdateEmployee(long id, [FromBody] EmployeeUpdateDTO employeeUpdateDTO)
{
employeeService.UpdateEmployee(id, employeeUpdateDTO);
return(Ok());
}
public void UpdateEmployee(EmployeeUpdateDTO employee, Guid empployeeID)
{
var employee_repos = mapper.Map <Employee>(employee);
repository.UpdateEmployee(employee_repos, empployeeID);
}
