public ActionResult Update(UpdateEmployee model)
{
if (ModelState.IsValid)
{
if (manager.SaveEmployee(model.Employee.ToEmployee()))
{
TempData["Message"] = new ResponseMessage()
{
Error = false,
Message = "Employee was successfully saved to the ChildWatch database."
};
}
else
{
TempData["Message"] = new ResponseMessage()
{
Error = true,
Message = "Employee was unable to be saved to the database."
};
}
}
ViewBag.isAdmin = model.Employee.Administrator;
ViewBag.isReset = model.Employee.NeedsReset;
ViewBag.isBlocked = model.Employee.Blocked;
return(View(model));
}
public async Task <IActionResult> UpdateEmployee([FromQuery] UpdateEmployee employee)
{
if (employee.EmployeeId.HasValue == false)
{
return(StatusCode((int)HttpStatusCode.InternalServerError, "Не задан идентификатор пользователя"));
}
if (string.IsNullOrWhiteSpace(employee.LastName))
{
return(StatusCode((int)HttpStatusCode.InternalServerError, "Фамилия не может быть пустой"));
}
if (string.IsNullOrWhiteSpace(employee.FirstName))
{
return(StatusCode((int)HttpStatusCode.InternalServerError, "Имя не может быть пустым"));
}
if (employee.DepartmentId.HasValue == false)
{
return(StatusCode((int)HttpStatusCode.InternalServerError, "Не задан идентификатор отдела"));
}
try
{
await _repository.UpdateEmployee(employee);
return(Ok());
}
catch (Exception ex)
{
return(StatusCode((int)HttpStatusCode.InternalServerError, ex.Message));
}
}
// GET: Employee/Edit/5
public ActionResult Edit(int id)
{
UpdateEmployee ViewModel = new UpdateEmployee();
string url = "employeedata/findemployee/" + id;
HttpResponseMessage response = client.GetAsync(url).Result;
//Can catch the status code (200 OK, 301 REDIRECT), etc.
//Debug.WriteLine(response.StatusCode);
if (response.IsSuccessStatusCode)
{
//Put data into job hunters data transfer object
EmployeeDto SelectedEmployee = response.Content.ReadAsAsync <EmployeeDto>().Result;
ViewModel.employee = SelectedEmployee;
//get information about job postings this job hunters belong to.
//url = "job_postingdata/getjob_postings";
//response = client.GetAsync(url).Result;
//IEnumerable<Job_PostingDto> PotentialJob_Postings = response.Content.ReadAsAsync<IEnumerable<Job_PostingDto>>().Result;
//ViewModel.alljob_postings = PotentialJob_Postings;
return(View(ViewModel));
}
else
{
return(RedirectToAction("Error"));
}
}
public async Task <IActionResult> UpdateAsync([FromRoute] Guid id, [FromBody] UpdateEmployee command)
{
command.Bind(cmd => cmd.Id, id);
await _commandDispatcher.DispatchAsync(command);
return(Ok());
}
public async Task Should_Delete_Specific_Employee_In_Specific_Company_When_Delete_Employee_In_Specific_Company()
{
// given
await client.DeleteAsync("Company/clear");
Employee employee = new Employee("Jack", 12000);
Company company = new Company(name: "Apple")
{
Employees = new List <Employee> {
employee
}
};
string request = JsonConvert.SerializeObject(company);
StringContent requestBody = new StringContent(request, Encoding.UTF8, "application/json");
await client.PostAsync("Company/companies", requestBody);
// when
UpdateEmployee updateEmployee = new UpdateEmployee("Rose", 30000);
string patchRequest = JsonConvert.SerializeObject(updateEmployee);
StringContent patchRequestBody = new StringContent(patchRequest, Encoding.UTF8, "application/json");
await client.DeleteAsync($"Company/companies/{company.Id}/{employee.Id}");
var response = await client.GetAsync($"Company/companies/{company.Id}/employees");
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();
List <Employee> actualEmployees = JsonConvert.DeserializeObject <List <Employee> >(responseString);
// then
Assert.Null(actualEmployees.Find(thisCompany => thisCompany.Id == company.Id)?.ToString());
}
public ActionResult Update()
{
var model = new UpdateEmployee();
ViewBag.isAdmin = model.Employee.Administrator;
ViewBag.isReset = model.Employee.NeedsReset;
ViewBag.isBlocked = model.Employee.Blocked;
return(View(model));
}
public ActionResult Update(UpdateEmployee updateEmployee)
{
if (this.ModelState.IsValid)
{
updateEmployee.ExecuteNonQuery();
return(Redirect("/Settings/Employee"));
}
return(View("FormPage", updateEmployee));
}
public object Put(UpdateEmployee request)
{
var entity = request.ConvertTo <Employee>();
return(InTransaction(db =>
{
Logic.Update(entity);
return new CommonResponse(Logic.GetById(entity.Id));
}));
}
public async Task HandleAsync_Should_Throw_An_Exception_When_Employee_With_Given_Id_Does_Not_Exist()
{
//ARRANGE
var command = new UpdateEmployee(Guid.NewGuid(), Position.Opiekun, "Avatar");
//ACT
var exception = await Record.ExceptionAsync(async() => await Act(command));
//Assert
exception.ShouldNotBeNull();
exception.ShouldBeAssignableTo <EmployeeDoesntExistException>();
}
public void UpdateEmployee(int id, UpdateEmployee newState)
{
if (!Exists(id))
{
return;
}
var employee = DbContext.Employees.First(e => e.EmployeeId == id);
employee.FirstName = newState.FirstName;
DbContext.SaveChanges();
}
internal static Entities.Employee MapToEntity(int id, UpdateEmployee employee)
{
return(new Entities.Employee
{
Id = id,
SSN = employee.SSN,
FirstName = employee.FirstName,
LastName = employee.LastName,
PhoneNumber = employee.PhoneNumber,
EmailAddress = employee.EmailAddress
});
}
protected void Button1_Click(object sender, EventArgs e)
{
EmployeeDAO dao = new EmployeeDAO();
UpdateEmployee insert = new UpdateEmployee();
insert.Employee.Ename = ename.Text;
insert.Employee.Birth = Util.GetDateTime(birth.Text);
insert.Employee.DepartId = int.Parse(DropDownList1.SelectedValue);
insert.Employee.Password = pwd.Text;
insert.Employee.Status = Convert.ToInt32(status.Text);
dao.Insert(insert);
Response.Redirect("searchEmp.aspx");
}
public ActionResult PUT(int id, UpdateEmployee modifiedEmployee)
{
var service = new EmployeeService();
if (!service.Exists(id))
{
return(NotFound());
}
service.UpdateEmployee(id, modifiedEmployee);
return(NoContent());
}
public async Task HandleAsync_Should_Update_Deliverer_With_Given_Id_Using_Repository()
{
//ARRANGE
var command = new UpdateEmployee(Guid.NewGuid(), Position.Opiekun, "Avatar");
var employee = new Employee(command.Id, "No Avatar", "Testowy Testo", Position.Grabarz, 1980);
_repository.GetAsync(command.Id).Returns(employee);
//ACT
await Act(command);
//ASSERT
await _repository.Received(1).UpdateAsync(employee);
}
public Controller()
{
objectFactory = new ObjectFactory();
securityManager = new SecurityManager();
this.openingDialogBox = new SignIn(this);
profile = new EmployeeProfile(this);
ForgotPassword = new ForgotPassword(this);
updateEmployee = new UpdateEmployee();
viewEmployee = new ViewEmployee(this);
createOrder = new Invoice(this);
reportsHome = new ReportsHome(this);
viewOrders = new ViewOrders(this);
addProduct_Form = new AddProduct(this);
}
public IActionResult UpdateEmployeeById(string companyId, string employeeId, UpdateEmployee updateEmployee)
{
var company = companies.FirstOrDefault(company => company.Id == companyId);
var employees = company.Employees;
var findEmploy = employees.FirstOrDefault(employee => employee.Id == employeeId);
if (findEmploy != null)
{
findEmploy.Salary = updateEmployee.Salary;
var afterEmploy = employees.FirstOrDefault(employee => employee.Id == employeeId);
return(Ok(afterEmploy));
}
return(NotFound());
}
public IActionResult Put(int id, [FromBody] UpdateEmployee employee)
{
if (!ModelState.IsValid)
{
var message = string.Join(", ", ModelState.Values.SelectMany(m => m.Errors).Select(m => m.ErrorMessage));
return(BadRequest(message));
}
var entity = EmployeesMapper.MapToEntity(id, employee);
employeeService.Update(entity);
var createdEmployee = EmployeesMapper.MapToApiModel(entity);
return(Ok(createdEmployee));
}
public async Task <IActionResult> SaveUpdateEmployee(UpdateEmployee updateEmployee)
{
try
{
if (ModelState.IsValid)
{
await _empleadoRepository.UpdateEmployee(_mapper.Map <Empleado>(updateEmployee));
return(RedirectToAction(nameof(Index)));
}
} catch (Exception)
{
return(BadRequest());
}
return(View("EditEmployee", updateEmployee));
}
public async Task Should_return_updated_employee_when_update_employee_in_certain_company_with_certain_id()
{
await client.DeleteAsync("Companies/clear");
var company1 = new Company("Sun");
var company2 = new Company("Moon");
string request1 = JsonConvert.SerializeObject(company1);
string request2 = JsonConvert.SerializeObject(company2);
StringContent requestBody1 = new StringContent(request1, Encoding.UTF8, "application/json");
StringContent requestBody2 = new StringContent(request2, Encoding.UTF8, "application/json");
//when
var responseWithId = await client.PostAsync("/Companies", requestBody1);
await client.PostAsync("/Companies", requestBody2);
responseWithId.EnsureSuccessStatusCode();
var responseStringWithId = await responseWithId.Content.ReadAsStringAsync();
Company actualWithId = JsonConvert.DeserializeObject <Company>(responseStringWithId);
var id = actualWithId.Id;
var employee1 = new Employee("1", "Mike", "6000");
var employee2 = new Employee("2", "Jane", "8000");
var updateEmploy = new UpdateEmployee("Mike", "9000");
string employeeRequest1 = JsonConvert.SerializeObject(employee1);
string employeeRequest2 = JsonConvert.SerializeObject(employee2);
string updateEmployRequest = JsonConvert.SerializeObject(updateEmploy);
StringContent employeeRequestBody1 = new StringContent(employeeRequest1, Encoding.UTF8, "application/json");
StringContent employeeRequestBody2 = new StringContent(employeeRequest2, Encoding.UTF8, "application/json");
StringContent updateEmployeeRequestBody = new StringContent(updateEmployRequest, Encoding.UTF8, "application/json");
var employeeResponse1 = await client.PostAsync($"/Companies/{id}/Employees", employeeRequestBody1);
var employeeResponse2 = await client.PostAsync($"/Companies/{id}/Employees", employeeRequestBody2);
var updatedEmployeeResponse = await client.PatchAsync($"/Companies/{id}/Employees/1", updateEmployeeRequestBody);
//then
updatedEmployeeResponse.EnsureSuccessStatusCode();
var responseString = await updatedEmployeeResponse.Content.ReadAsStringAsync();
Employee actual = JsonConvert.DeserializeObject <Employee>(responseString);
Assert.Equal(new Employee("1", "Mike", "9000"), actual);
}
public void Update(UpdateEmployee employee)
{
var person = _repository.Get().FirstOrDefault(x => x.Id == employee.Id);
if (person != null)
{
person.LastName = employee.LastName;
person.FirstName = employee.FirstName;
person.MiddleName = employee.MiddleName;
person.MobilePhone = employee.MobilePhone;
person.State = employee.State;
person.Email = employee.Email;
_repository.Update(person);
_repository.SaveChanges();
}
}
public async Task <IActionResult> Update(UpdateEmployee model, int id)
{
// Validation failed ==> ApiController does this automatically
// if (!ModelState.IsValid)
// {
// return BadRequest(ModelState);
// }
var employee = await _context.Employees.FindAsync(id);
// Employee not found
if (employee is null)
{
return(BadRequest(new
{
Success = false,
Message = "Unable to find employee"
}));
}
// Map new values to domain model ==> for production use look into AutoMapper Library
employee.Name = model.Name;
employee.Age = model.Age;
employee.Office = model.Office;
employee.Position = model.Position;
employee.Salary = model.Salary;
employee.StartDate = model.StartDate;
// Save changes to DB ==> for production look into Unit Of Work (UOW) pattern
await _context.SaveChangesAsync();
// Wait 4 secs so you can see live update
await Task.Delay(4000);
// Update all clients ==> for production look into groups & users to narrow down subscribers
await _hub.Clients.All.EmployeeUpdated(employee);
return(Ok(new
{
Success = true,
Message = "Employee Updated Successfully"
}));
}
public async Task <IActionResult> UpdateAsync([FromBody] UpdateEmployee request, CancellationToken cancellationToken)
{
var employee = await _employeeRepository.GetAsync(request.EmployeeId, cancellationToken);
if (employee is null)
{
return(NotFound());
}
if (request.Name != null)
{
employee.ChangeName(request.Name);
}
if (request.DepartmentId.HasValue)
{
employee.TransferDepartment(request.DepartmentId.Value);
}
await _employeeRepository.UnitOfWork.SaveChangesAsync(cancellationToken);
return(Ok());
}
/// <summary>
/// Uppdatera en specifik anställd
/// </summary>
/// <returns>Den uppdaterade anställda</returns>
public EmployeeResponse Put(UpdateEmployee request)
{
var employee = EmployeeRepository.GetEmployee(request.Id);
if (employee == null)
{
Response.StatusCode = (int)HttpStatusCode.NotFound;
return(null);
}
if (!DepartmentRepository.GetDepartments().Any(x => x.Id == request.DepartmentId))
{
Response.StatusCode = (int)HttpStatusCode.BadRequest;
return(null);
}
EmployeeRepository.UpdateEmployee(employee.Id, request.FirstName, request.LastName, request.Title, request.DepartmentId);
return(new EmployeeResponse
{
Employee = EmployeeRepository.GetEmployee(employee.Id).ToDto()
});
}
public ActionResult UpdateEmployee(UpdateEmployee UpdatedEmployee)
{
_logger.LogInformation(MethodBase.GetCurrentMethod().Name + " called");
try
{
var ModifiedEmployee = _mapper.Map <Employee>(UpdatedEmployee);
var EmployeeId = _repository.UpdateEmployee(ModifiedEmployee).Result;
if (EmployeeId == null)
{
return(NotFound());
}
var output = new Result <Guid>()
{
Data = EmployeeId,
Message = "Updated Employee Id"
};
return(CreatedAtRoute(nameof(GetEmployeeById), new { Id = output.Data }, output));
}
catch (Exception ex)
{
_logger.LogError(ex.ToString());
}
return(NotFound());
}
public async Task <ActionResult> Update(long id, UpdateEmployee command)
{
return(Ok(await _mediator.Send(command.Bind(x => x.Id, id))));
}
public IActionResult Put(UpdateEmployee employee)
{
_employeeService.Update(employee);
return(Ok());
}
private async void TSB_UpdateUser_Click(object sender, EventArgs e)
{
await UpdateEmployee?.Invoke();
}
private async void B_Setting_Click(object sender, RoutedEventArgs e)
{
await UpdateEmployee.Invoke();
}
public async Task <int> UpdateEmployee(UpdateEmployee employee)
{
int id = 0;
var update = new Employee
{
Id = employee.Id,
FullName = employee.FullName,
PositionId = employee.PositionId,
DepartmentId = employee.DepartmentId,
Sex = employee.Sex != 0,
Dob = employee.DOB,
IdNumber = employee.IdNumber,
PhoneNumber = employee.PhoneNumber,
Email = employee.Email,
Address = employee.Address,
TaxId = employee.TaxId,
Image = employee.Image,
EditDate = employee.EditDate,
IsActive = true
};
try
{
if (update.PositionId == 1)
{
int select = await(from e in db.Employee
where e.PositionId == 1 && e.DepartmentId == update.DepartmentId &&
e.IsDelete == false && e.IsActive == true
select e.Id).FirstOrDefaultAsync();
if (select != 0)
{
var emp = await(from e in db.Employee
where e.PositionId == 1 && e.DepartmentId == update.DepartmentId &&
e.IsDelete == false && e.IsActive == true
select e).FirstOrDefaultAsync();
var updateEmployee = new Employee
{
Id = emp.Id,
PositionId = 3,
FullName = emp.FullName,
DepartmentId = emp.DepartmentId,
Sex = emp.Sex,
Dob = emp.Dob,
IdNumber = emp.IdNumber,
PhoneNumber = emp.PhoneNumber,
Email = emp.Email,
Address = emp.Address,
TaxId = emp.TaxId,
Image = emp.Image,
EditDate = emp.EditDate,
IsActive = true
};
db.Employee.Update(updateEmployee);
await db.SaveChangesAsync();
return(id = updateEmployee.Id);
}
}
db.Employee.Update(update);
await db.SaveChangesAsync();
return(id = update.Id);
}
catch (Exception exp)
{
throw exp;
}
}
public async Task <IActionResult> EditEmployee(UpdateEmployee updateEmployee)
{
ViewBag.Areas = new SelectList(await _areaRepository.GetAllAreas(), "IdArea", "Nombre");
return(View("EditEmployee", updateEmployee));
}
