private async void btnSaveChanges_Click(object sender, EventArgs e)
{
if (!ValidateChildren())
{
MessageBox.Show("Podaci nisu ispravni", "Greška", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
if (!chkActive.Checked)
{
if (MessageBox.Show(
Messages.delete_warning, "Upozorenje", MessageBoxButtons.YesNo, MessageBoxIcon.Warning) == DialogResult.No)
{
return;
}
}
var request = new EmployeeUpdateRequest()
{
Active = chkActive.Checked,
ContractSigned = txtContractDate.Value,
LastName = txtSurname.Text,
FirstName = txtName.Text,
Position = txtPosition.Text,
Salary = decimal.Parse(txtSalary.Text)
};
var result = await _service.Update <EToolService.Model.Models.Employee>(_id, request);
MessageBox.Show("Uspješno ste promijenili podatke za uposlenika.", "Info", MessageBoxButtons.OK, MessageBoxIcon.Information);
this.Close();
ParentForm.LoadForm();
}
public void CreatePerson_UpdateEmployee_UpdateSocialNetworkProfile()
{
Guid id = CreateMyself();
EmployeeUpdateRequest employeeUpdateRequest = new EmployeeUpdateRequest()
{
Id = id,
Employer = "VML"
};
manager.UpdateEmployee(employeeUpdateRequest);
Employee employee = manager.LoadPerson <Employee>(id);
Assert.AreEqual(employeeUpdateRequest.Employer, employee.Employer);
Assert.AreEqual("Chris", employee.FirstName);
Assert.AreEqual("Elston", employee.LastName);
Assert.AreEqual(new DateTime(1980, 7, 26), employee.BirthDate);
SocialNetworkProfileUpdateRequest socialNetworkProfileUpdateRequest = new SocialNetworkProfileUpdateRequest()
{
Id = id,
UsesTwitter = true,
TwitterUsername = "******"
};
manager.UpdateSocialNetworkProfile(socialNetworkProfileUpdateRequest);
CreatePerson_UpdateEmployee_UpdateSocialNetworkProfile_Asserts();
}
public async Task <IActionResult> Update([FromBody] EmployeeUpdateRequest request)
{
var affected = await _manageEmployeeService.Update(request);
if (affected == 0)
{
return(BadRequest());
}
return(Ok());
}
//update employee
/// <summary>
/// entity to modify: Employee
/// </summary>
/// <param name="employeeUpdateRequest"></param>
/// <param name="employee"></param>
/// <returns></returns>
public static Employee MapFromEmployeeUpdateRequestToEmployee(EmployeeUpdateRequest employeeUpdateRequest, Employee employee)
{
employee.Name = employeeUpdateRequest.Name;
employee.Age = employeeUpdateRequest.Age;
employee.PhoneNumber = employeeUpdateRequest.PhoneNumber;
employee.DepartmentId = employeeUpdateRequest.DepartmentId;
employee.PositionId = employeeUpdateRequest.PositionId;
return(employee);
}
public async Task <bool> Update(int MaNV, EmployeeUpdateRequest request)
{
var json = JsonConvert.SerializeObject(request);
var httpContent = new StringContent(json, Encoding.UTF8, "application/json");
var client = _httpClientFactory.CreateClient();
client.BaseAddress = new Uri(_configuration["BaseAddress"]);
var response = await client.PutAsync($"/api/Employee/Update?Manv={MaNV}", httpContent);
return(response.IsSuccessStatusCode);
}
public async Task <IActionResult> Update(EmployeeUpdateRequest request)
{
if (!ModelState.IsValid)
{
return(View());
}
var result = await _employeeApiClient.Update(request.MaNV, request);
if (result)
{
return(RedirectToAction("Index", "Home"));
}
return(View(request));
}
public async Task <int> Update(EmployeeUpdateRequest request)
{
var nhanvien = await _context.NhanViens.FindAsync(request.MaNV);
if (nhanvien == null)
{
throw new EQuanLyNhanSuException($"Can not update user: {request.MaNV}");
}
nhanvien.TenNv = request.TenNv;
nhanvien.GioiTinh = request.GioiTinh;
nhanvien.ChucVu = request.ChucVu;
nhanvien.MaPb = request.MaPb;
nhanvien.CMND = request.CMND;
nhanvien.NgaySinh = request.NgaySinh;
return(await _context.SaveChangesAsync());
}
public ActionResult <EmployeeResponse> UpdateEmployee(int id, EmployeeUpdateRequest request)
{
var cityToUpdate = _employeeRepository.FindEmployeeById(id);
if (cityToUpdate == null)
{
return(NotFound());
}
if (!ModelState.IsValid)
{
return(BadRequest());
}
var result = _employeeRepository.UpdateEmployee(id, request);
return(Ok(result));
}
public EmployeeResponse Update(EmployeeUpdateRequest request)
{
using (var adapter = DataAccessAdapterFactory.NewDataAccessAdapter())
{
OnBeforeEmployeeUpdateRequest(adapter, request);
var entity = request.FromDto();
entity.IsNew = false;
entity.IsDirty = true;
if (adapter.SaveEntity(entity, true))
{
OnAfterEmployeeUpdateRequest(adapter, request);
return(new EmployeeResponse(entity.ToDto()));
}
}
throw new InvalidOperationException();
}
public void UpdateEmployee(int id, EmployeeUpdateRequest model)
{
using (SqlConnection conn = new SqlConnection(connectionString))
{
conn.Open();
SqlCommand cmd = conn.CreateCommand();
cmd.CommandText = "dbo.Employee_Update";
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@Id", id);
cmd.Parameters.AddWithValue("@FirstName", model.FirstName);
cmd.Parameters.AddWithValue("@LastName", model.LastName);
cmd.Parameters.AddWithValue("@HiredDate", model.HiredDate);
DataTable taskTable = null;
if (model.Tasks.Count > 0)
{
taskTable = new DataTable();
taskTable.Columns.Add("Name", typeof(string));
taskTable.Columns.Add("StartTime", typeof(DateTime));
taskTable.Columns.Add("Deadline", typeof(DateTime));
foreach (var item in model.Tasks)
{
DataRow dr = taskTable.NewRow();
dr[0] = item.Name;
dr[1] = item.StartTime;
dr[2] = item.Deadline;
taskTable.Rows.Add(dr);
}
}
cmd.Parameters.AddWithValue("@Tasks", taskTable);
cmd.ExecuteNonQuery();
conn.Close();
}
}
public async Task <IActionResult> Update([FromBody] EmployeeUpdateRequest requestModel)
{
//if (!ModelState.IsValid)
//{
// return BadRequest(ModelState);
//}
Employee employee = await employeeService.FindEmployeeAsync(requestModel.Id);
if (employee == null)
{
return(ModelNotFound(logger.Here(), requestModel.Id));
}
EmployeeMapper.MapFromEmployeeUpdateRequestToEmployee(requestModel, employee);
db.Employees.Update(employee);
await db.SaveChangesAsync();
logger.Here().Information("Updated employee successfully");
return(NoContent());
}
public Model.Models.Employee Update(int?id, EmployeeUpdateRequest request)
{
if (id == null)
{
throw new UserException("ID ne može biti prazno polje");
}
var entity = _context.Employee.Find(id);
if (entity == null)
{
throw new UserException("Korisnik nije pronađen");
}
UpdateEmployee(entity, request);
var result = _mapper.Map <Model.Models.Employee>(entity);
GetEmployeeRequests(result);
GetEmployeeMachines(result);
return(result);
}
partial void OnAfterEmployeeUpdateRequest(IDataAccessAdapter adapter, EmployeeUpdateRequest request);
public Model.Models.Employee Update(int?id, [FromBody] EmployeeUpdateRequest request)
{
return(_employeeService.Update(id, request));
}
