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)); }