public async Task Should_delete_company()
        {
            // given
            CompanyUpdateModel companyUpdateModel = new CompanyUpdateModel(name: "Apple");
            string             request            = JsonConvert.SerializeObject(companyUpdateModel);
            StringContent      requestBody        = new StringContent(request, Encoding.UTF8, "application/json");
            await client.PostAsync("companies", requestBody);

            EmployeeUpdateModel employeeUpdateModel = new EmployeeUpdateModel(name: "Steve", salary: 100);
            string        request2     = JsonConvert.SerializeObject(employeeUpdateModel);
            StringContent requestBody2 = new StringContent(request2, Encoding.UTF8, "application/json");
            await client.PostAsync("companies/Apple/employees", requestBody2);

            // when
            await client.DeleteAsync("companies/Apple");

            var response = await client.GetAsync("companies");

            response.EnsureSuccessStatusCode();
            var responseString = await response.Content.ReadAsStringAsync();

            List <Company> actualEmployees = JsonConvert.DeserializeObject <List <Company> >(responseString);

            // then
            Assert.Equal(new List <Company>(), actualEmployees);
        }
        public async Task Should_Change_Specified_Employee_In_Specified_Company_When_Patch_UpdateEmployee()
        {
            // given
            await testClient.DeleteAsync("companies/clear");

            Company  company1    = new Company("0", "Baymax");
            Employee newEmployee = new Employee("0", "Jim", 10000);

            company1.Employees["0"] = newEmployee;
            string        request1     = JsonConvert.SerializeObject(company1);
            StringContent requestBody1 = new StringContent(request1, Encoding.UTF8, "application/json");
            await testClient.PostAsync("/companies", requestBody1);

            // when
            var           employeeUpdateModel = new EmployeeUpdateModel("Jim", 12000);
            string        request             = JsonConvert.SerializeObject(employeeUpdateModel);
            StringContent requestBody         = new StringContent(request, Encoding.UTF8, "application/json");
            await testClient.PatchAsync("/companies/0/employees/0", requestBody);

            // then
            var getResponse = await testClient.GetAsync("companies/0");

            var getResponseString = await getResponse.Content.ReadAsStringAsync();

            var actualCompany    = JsonConvert.DeserializeObject <Company>(getResponseString);
            var expectedEmployee = new Employee("0", "Jim", 12000);

            Assert.Equal(expectedEmployee, actualCompany.Employees["0"]);
        }
Esempio n. 3
0
        public async Task Should_Update_Employee_Info_When_Put()
        {
            // given
            var           company          = new UpdateModel("testcompany");
            string        request          = JsonConvert.SerializeObject(company);
            var           employee1        = new Employee("employeename1", 10000);
            string        postRequest1     = JsonConvert.SerializeObject(employee1);
            StringContent postRequestBody1 = new StringContent(postRequest1, Encoding.UTF8, "application/json");

            var           employeeUpdateModel = new EmployeeUpdateModel("employeeputname", 5000);
            string        putRequest          = JsonConvert.SerializeObject(employeeUpdateModel);
            StringContent requestBody         = new StringContent(request, Encoding.UTF8, "application/json");
            StringContent putRequestBody      = new StringContent(putRequest, Encoding.UTF8, "application/json");

            // when
            await client.PostAsync("company", requestBody);

            await client.PostAsync("company/1", postRequestBody1);

            await client.PutAsync("company/1/employees/1", putRequestBody);

            var getResponse = await client.GetAsync("company/1/employees/1");

            getResponse.EnsureSuccessStatusCode();
            var responseString = await getResponse.Content.ReadAsStringAsync();

            Employee actualEmployee = JsonConvert.DeserializeObject <Employee>(responseString);

            // then
            Assert.Equal(5000, actualEmployee.Salary);
        }
        public async Task Should_change_employee_information()
        {
            // given
            CompanyUpdateModel companyUpdateModel = new CompanyUpdateModel(name: "Apple");
            string             request            = JsonConvert.SerializeObject(companyUpdateModel);
            StringContent      requestBody        = new StringContent(request, Encoding.UTF8, "application/json");
            await client.PostAsync("companies", requestBody);

            EmployeeUpdateModel employeeUpdateModel = new EmployeeUpdateModel(name: "Steve", salary: 100);
            string        request2     = JsonConvert.SerializeObject(employeeUpdateModel);
            StringContent requestBody2 = new StringContent(request2, Encoding.UTF8, "application/json");
            await client.PostAsync("companies/Apple/employees", requestBody2);

            // when
            EmployeeUpdateModel employeeUpdateModel3 = new EmployeeUpdateModel(name: "Jobs", salary: 200);
            string        request3     = JsonConvert.SerializeObject(employeeUpdateModel3);
            StringContent requestBody3 = new StringContent(request3, Encoding.UTF8, "application/json");
            var           response     = await client.PatchAsync("companies/Apple/employees/Steve", requestBody3);

            response.EnsureSuccessStatusCode();
            var responseString = await response.Content.ReadAsStringAsync();

            Employee actualEmployees = JsonConvert.DeserializeObject <Employee>(responseString);

            // then
            Assert.Equal(new Employee(name: "Jobs", salary: 200), actualEmployees);
        }
Esempio n. 5
0
        public IActionResult Put(uint empID, [FromBody] EmployeeUpdateModel emp)
        {
            db.OpenConnection();

            try
            {
                string sqlStatementDesc = "UPDATE employee SET pin_number = @pinNumber, admin = @admin, first_name = @firstName, last_name = @lastName, email = @email, addr1 = @addr1, addr2 = @addr2, city = @city, state = @state, zip = @zip, phone = @phone WHERE emp_id = @empID";

                MySqlCommand cmd = new MySqlCommand(sqlStatementDesc, db.Connection());
                cmd.Parameters.Add(new MySqlParameter("pinNumber", emp.PinNumber));
                cmd.Parameters.Add(new MySqlParameter("admin", emp.IsAdmin));
                cmd.Parameters.Add(new MySqlParameter("firstName", emp.FirstName));
                cmd.Parameters.Add(new MySqlParameter("lastName", emp.LastName));
                cmd.Parameters.Add(new MySqlParameter("email", emp.Email));
                cmd.Parameters.Add(new MySqlParameter("addr1", emp.Address1));
                cmd.Parameters.Add(new MySqlParameter("addr2", emp.Address2));
                cmd.Parameters.Add(new MySqlParameter("city", emp.City));
                cmd.Parameters.Add(new MySqlParameter("state", emp.State));
                cmd.Parameters.Add(new MySqlParameter("zip", emp.ZipCode));
                cmd.Parameters.Add(new MySqlParameter("phone", emp.PhoneNumber));
                cmd.Parameters.Add(new MySqlParameter("empID", empID));
                MySqlDataReader reader = cmd.ExecuteReader();
                reader.Read();
                reader.Close();
            }
            catch (Exception ex)
            {
                throw ex;
            }
            db.CloseConnnection();
            Console.WriteLine("\nConnection closed.");
            return(Ok());
        }
Esempio n. 6
0
        public async Task <IHttpActionResult> ApproveEmployee(int clientId, [FromBody] EmployeeUpdateModel model)
        {
            var userId   = GetUserId();
            var employee = await _employeeManager.ApproveEmployeeAsync(model, clientId, userId);

            return(Ok(employee));
        }
        public async Task <ActionResult> UpdateEmployee(EmployeeUpdateModel model)
        {
            if (ModelState.IsValid)
            {
                var user = await EmployeeManager.Users.FirstOrDefaultAsync(u => u.UserName == model.Username);

                user.FirstName    = model.FirstName;
                user.LastName     = model.LastName;
                user.PayRate      = model.Payrate;
                user.OverTimeRate = model.OvertimeRate;
                user.TaxRate      = model.TaxRate;
                user.PayMethod    = model.PayMethod;
                user.PhoneNumber  = model.Phone;
                user.Address      = model.Address;

                var result = await EmployeeManager.UpdateAsync(user);

                if (result.Succeeded)
                {
                    return(RedirectToAction("Index", "Admin", new { message = "Employee updated successfully." }));
                }

                AddErrors(result);
            }

            // If we got this far, something failed, redisplay form
            return(View(model));
        }
Esempio n. 8
0
 private void SetEmployeeValues(Employee employee, EmployeeUpdateModel modelItem)
 {
     employee.FirstName   = modelItem.Firstname;
     employee.LastName    = modelItem.Lastname;
     employee.DateOfBirth = modelItem.DateOfBirth;
     employee.JobTitle    = modelItem.JobTitle;
 }
Esempio n. 9
0
        public async Task <IActionResult> Put(Guid id, EmployeeUpdateModel model)
        {
            var updatedEmployee = await _employeeService.UpdateAsync(id, model);

            var response = new Response(updatedEmployee);

            return(Ok(response));
        }
Esempio n. 10
0
        public Employee UpdateEmployee(string companyId, string employeeId, EmployeeUpdateModel employeeUpdateModel)
        {
            var company  = companies.GetCompanyByID(companyId);
            var employee = company.GetEmployeeById(employeeId);

            employee.Name   = employeeUpdateModel.Name;
            employee.Salary = employeeUpdateModel.Salary;
            return(employee);
        }
Esempio n. 11
0
        public IActionResult Put([FromBody] EmployeeUpdateModel model)
        {
            var response = _commandBus.Execute <EmployeeCreateCommand, EmployeeCreateResponse>(new EmployeeCreateCommand
            {
                FirstName = model.FirstName,
                LastName  = model.LastName,
                Email     = model.Email
            });

            return(response.Succeeded ? Json("ok") : Json("error"));
        }
Esempio n. 12
0
        public async Task <Employee> UpdateEmployee(int id, EmployeeUpdateModel model)
        {
            var employee = await this.dbContext
                           .Employees
                           .Include(x => x.Garage)
                           .FirstOrDefaultAsync(x => x.Id == id);

            employee.Name = model.Name;

            await this.dbContext.SaveChangesAsync();

            return(employee);
        }
        public async void Should_Delete_Employees_Before_Deleting_Company()
        {
            // given
            Company       company     = new Company("company_name_1");
            string        request     = JsonConvert.SerializeObject(company);
            StringContent requestBody = new StringContent(request, Encoding.UTF8, "application/json");

            Employee      employee_1            = new Employee("Tom", 5000);
            string        employeeRequest_1     = JsonConvert.SerializeObject(employee_1);
            StringContent employeeRequestBody_1 = new StringContent(employeeRequest_1, Encoding.UTF8, "application/json");
            Employee      employee_2            = new Employee("Jerry", 3000);
            string        employeeRequest_2     = JsonConvert.SerializeObject(employee_2);
            StringContent employeeRequestBody_2 = new StringContent(employeeRequest_2, Encoding.UTF8, "application/json");

            // when
            await client.PostAsync("company/companies", requestBody);

            string companyId  = "company_1";
            string employeeId = "employee_2";
            EmployeeUpdateModel updateModel = new EmployeeUpdateModel("Fred", 10000);
            string        updateRequest     = JsonConvert.SerializeObject(updateModel);
            StringContent updateRequestBody = new StringContent(updateRequest, Encoding.UTF8, "application/json");
            await client.PostAsync($"company/companies/{companyId}/employees", employeeRequestBody_1);

            await client.PostAsync($"company/companies/{companyId}/employees", employeeRequestBody_2);

            await client.DeleteAsync($"company/companies/{companyId}/employees");

            var response = await client.GetAsync($"company/companies/{companyId}/employees");

            // then
            response.EnsureSuccessStatusCode();
            var responseString = await response.Content.ReadAsStringAsync();

            List <Employee> actualEmployees   = JsonConvert.DeserializeObject <List <Employee> >(responseString);
            List <Employee> expectedEmployees = new List <Employee>();

            Assert.Equal(expectedEmployees, actualEmployees);

            await client.DeleteAsync($"company/companies/{companyId}");

            response = await client.GetAsync($"company/companies");

            response.EnsureSuccessStatusCode();
            responseString = await response.Content.ReadAsStringAsync();

            List <Company> actualCompanies   = JsonConvert.DeserializeObject <List <Company> >(responseString);
            List <Company> expectedCompanies = new List <Company>();

            Assert.Equal(expectedCompanies, actualCompanies);
        }
Esempio n. 14
0
        public async Task <ActionResult <Employee> > AddEmployee(string companyName, EmployeeUpdateModel employeeUpdateModel)
        {
            var company = companies.FirstOrDefault(c => c.Name == companyName);

            if (company == null)
            {
                return(NotFound());
            }

            var employee = new Employee(employeeUpdateModel.Name, employeeUpdateModel.Salary);

            company.Employees.Add(employee);
            return(Ok(employee));
        }
Esempio n. 15
0
        public IActionResult Update(int employeeId, [FromBody] EmployeeUpdateModel model)
        {
            var employee = _mapper.Map <Employee>(model);

            try
            {
                _employeeService.Update(employee, employeeId);
                return(Ok());
            }
            catch (AppException ex)
            {
                return(BadRequest(new { message = ex.Message }));
            }
        }
Esempio n. 16
0
 public ActionResult Post(EmployeeUpdateModel employeeModel)
 {
     if (ModelState.IsValid)
     {
         var employee = _empoyeeRepository.Get(employeeModel.Id);
         if (employee != null)
         {
             employee.FirstName = employeeModel.FirstName;
             employee.LastName  = employeeModel.LastName;
             _empoyeeRepository.Update(employee);
             return(Ok());
         }
     }
     return(BadRequest());
 }
Esempio n. 17
0
        public static Employee EmployeMapWithEmployeeUpdateModel(EmployeeUpdateModel model)
        {
            Employee employee = new Employee();

            employee.Id           = model.id;
            employee.FirstName    = model.firstName;
            employee.LastName     = model.lastName;
            employee.UserId       = model.userId;
            employee.EmailId      = model.email;
            employee.DepartmentId = model.departmentId;
            employee.Gender       = model.gender;
            employee.CityId       = model.cityId;
            employee.CountryId    = model.countryId;
            return(employee);
        }
Esempio n. 18
0
        public async Task <int> Execute(EmployeeUpdateModel employeeModel)
        {
            _logger.Information("Updating Employee");

            try
            {
                var employee = _mapper.Map <Employee>(employeeModel);

                return(await _unitOfWork.Employees.UpdateAsync(employee));
            }
            catch (Exception ex)
            {
                _logger.Error(ex, ex.Message, null);
                throw;
            }
        }
        public async Task <ActionResult> Edit(EmployeeUpdateModel employee)
        {
            if (ModelState.IsValid)
            {
                bool isUpdated = await UserBAL.updateEmployee(employee);

                if (isUpdated)
                {
                    ViewBag.Updated = "true";
                }
            }
            ViewBag.DepartmentId = new SelectList(await DepartmentBAL.getDepartment(), "Id", "DepartmentName");
            ViewBag.CountryId    = new SelectList(entity.Countries, "Id", "CountryName");
            ViewBag.CityId       = new SelectList(entity.Cities, "Id", "CityName");
            return(View(employee));
        }
Esempio n. 20
0
        public async Task <EmployeeUpdateModel> UpdateAsync(EmployeeUpdateModel model, int clientId, int userId)
        {
            if (!await _permissionManager.HasPermission(clientId, userId, Permission.CanAddEmployee))
            {
                throw new Exception("User has not permission to perform this operation");
            }

            if (model == null)
            {
                throw new ArgumentNullException();
            }

            //check the employee shift extis or not
            var updateEmployeeShift = await _shiftHistroyManager.GetByEmployeeIdAsync(model.Id, clientId, userId);

            //This is used for update employee shift
            if (updateEmployeeShift == null || (updateEmployeeShift != null && updateEmployeeShift.ShiftId != model.ShiftId))
            {
                if (updateEmployeeShift != null)
                {
                    updateEmployeeShift.EndDate = DateTime.UtcNow;
                    await _shiftHistroyManager.UpdateAsync(updateEmployeeShift, clientId, userId);
                }
                //then afte update employee new shift timing
                var addNewEmployeeShift = new ShiftHistoryModel();
                addNewEmployeeShift.EmployeeId = model.Id;
                addNewEmployeeShift.ShiftId    = model.ShiftId;
                addNewEmployeeShift.StartDate  = DateTime.UtcNow;

                await _shiftHistroyManager.AddAsync(addNewEmployeeShift, clientId, userId);
            }

            var existingDataModel = await _employeeRepository.GetAsync(model.Id);

            if (existingDataModel == null)
            {
                throw new Exception("Employee does not exist which you trying to update");
            }

            var employee = _employeeUpdateMapper.ConvertToDataModel(model);

            employee.UpdatedOn = DateTime.UtcNow;

            employee = await _employeeRepository.UpdateAsync(employee);

            return(_employeeUpdateMapper.ConvertToModel(employee));
        }
Esempio n. 21
0
        public static EmployeeUpdateModel EmployeModelMapWithEmployeeUpdateModel(sp_GetEmployeeById_Result emp)
        {
            EmployeeUpdateModel employee = new EmployeeUpdateModel()
            {
                id           = emp.Id,
                userId       = emp.UserId,
                firstName    = emp.FirstName,
                lastName     = emp.LastName,
                email        = emp.EmailId,
                departmentId = (long)emp.DepartmentId,
                gender       = emp.Gender,
                cityId       = (int)emp.CityId,
                countryId    = (int)emp.CountryId
            };

            return(employee);
        }
Esempio n. 22
0
        public IActionResult Post([FromBody] EmployeeUpdateModel emp)
        {
            // first, check if employee ID already exists

            /*if (DoesEmployeeExist(tester.EmpID))
             * {
             *  return StatusCode(400, "Employee ID already exists.");
             * }*/

            try
            {
                db.OpenConnection();

                string sqlStatementDesc =
                    "SET SQL_MODE = '';" +
                    "INSERT INTO employee (pin_number, admin, first_name, last_name, email, addr1, addr2, city, state, zip, phone) " +
                    "VALUES (@pinNumber, @admin, @firstName, @lastName, @email, @addr1, @addr2, @city, @state, @zip, @phone)";
                MySqlCommand cmd = new MySqlCommand(sqlStatementDesc, db.Connection());
                cmd.Parameters.Add(new MySqlParameter("pinNumber", emp.PinNumber));
                cmd.Parameters.Add(new MySqlParameter("admin", emp.IsAdmin));
                cmd.Parameters.Add(new MySqlParameter("firstName", emp.FirstName));
                cmd.Parameters.Add(new MySqlParameter("lastName", emp.LastName));
                cmd.Parameters.Add(new MySqlParameter("email", emp.Email));
                cmd.Parameters.Add(new MySqlParameter("addr1", emp.Address1));
                cmd.Parameters.Add(new MySqlParameter("addr2", emp.Address2));
                cmd.Parameters.Add(new MySqlParameter("city", emp.City));
                cmd.Parameters.Add(new MySqlParameter("state", emp.State));
                cmd.Parameters.Add(new MySqlParameter("zip", emp.ZipCode));
                cmd.Parameters.Add(new MySqlParameter("phone", emp.PhoneNumber));
                MySqlDataReader reader = cmd.ExecuteReader();
                reader.Read();
                reader.Close();
            }
            catch (Exception ex)
            {
                return(Content(ex.Message));
            }
            db.CloseConnnection();
            Console.WriteLine("\nConnection closed.");

            return(Ok());
        }
Esempio n. 23
0
        public ActionResult CreateEmployee(string username)
        {
            if (username == null)
            {
                EmployeeRegisterViewModel model = new EmployeeRegisterViewModel
                {
                    LoggedUser    = CurrentUser,    //BaseViewModel
                    LoggedCompany = CurrentCompany, //BaseViewModel
                    LogoUrl       = CurrentLogoUrl, //BaseViewModel

                    HireDate = DateTime.Today
                };

                return(View(model));
            }

            var user = EmployeeManager.Users.FirstOrDefault(u => u.UserName == username);

            EmployeeUpdateModel employee = new EmployeeUpdateModel
            {
                LoggedUser    = CurrentUser,    //BaseViewModel
                LoggedCompany = CurrentCompany, //BaseViewModel
                LogoUrl       = CurrentLogoUrl, //BaseViewModel

                Username     = user.UserName,
                FirstName    = user.FirstName,
                LastName     = user.LastName,
                Payrate      = user.PayRate,
                OvertimeRate = user.OverTimeRate,
                Phone        = user.PhoneNumber,
                Address      = user.Address,
                TaxRate      = user.TaxRate,
                PayMethod    = user.PayMethod,
                PayMethods   = new List <PayMethod>()
                {
                    PayMethod.Hour, PayMethod.Day, PayMethod.Month, PayMethod.Year
                }
            };

            return(View("UpdateEmployee", employee));
        }
Esempio n. 24
0
        public async Task <IActionResult> UpdateEmployee([FromBody] EmployeeUpdateModel employeeModel)
        {
            try
            {
                // TO DO this validation could still be moved to a filter attribute
                if (employeeModel == null)
                {
                    _logger.Error("Employee object received is null.");
                    return(BadRequest("Employee object is null"));
                }

                var data = await _updateEmployeeCommand.Execute(employeeModel);

                return(Ok(data));
            }
            catch (Exception ex)
            {
                _logger.Error(ex, ex.Message, null);
                return(StatusCode(StatusCodes.Status500InternalServerError));
            }
        }
        public async void Should_Update_Employee_By_Id()
        {
            // given
            Company       company     = new Company("company_name_1");
            string        request     = JsonConvert.SerializeObject(company);
            StringContent requestBody = new StringContent(request, Encoding.UTF8, "application/json");

            Employee      employee_1            = new Employee("Tom", 5000);
            string        employeeRequest_1     = JsonConvert.SerializeObject(employee_1);
            StringContent employeeRequestBody_1 = new StringContent(employeeRequest_1, Encoding.UTF8, "application/json");
            Employee      employee_2            = new Employee("Jerry", 3000);
            string        employeeRequest_2     = JsonConvert.SerializeObject(employee_2);
            StringContent employeeRequestBody_2 = new StringContent(employeeRequest_2, Encoding.UTF8, "application/json");

            // when
            await client.PostAsync("company/companies", requestBody);

            string companyId  = "company_1";
            string employeeId = "employee_2";
            EmployeeUpdateModel updateModel = new EmployeeUpdateModel("Fred", 10000);
            string        updateRequest     = JsonConvert.SerializeObject(updateModel);
            StringContent updateRequestBody = new StringContent(updateRequest, Encoding.UTF8, "application/json");
            await client.PostAsync($"company/companies/{companyId}/employees", employeeRequestBody_1);

            await client.PostAsync($"company/companies/{companyId}/employees", employeeRequestBody_2);

            var response = await client.PatchAsync($"company/companies/{companyId}/employees/{employeeId}", updateRequestBody);

            // then
            response.EnsureSuccessStatusCode();
            var responseString = await response.Content.ReadAsStringAsync();

            Employee actualEmployee = JsonConvert.DeserializeObject <Employee>(responseString);

            employee_2.EmployeeID = "employee_2";
            employee_2.Name       = "Fred";
            employee_2.Salary     = 10000;
            Assert.Equal(employee_2, actualEmployee);
        }
Esempio n. 26
0
        public async Task <EmployeeUpdateModel> ApproveEmployeeAsync(EmployeeUpdateModel model, int clientId, int userId)
        {
            if (!await _permissionManager.HasPermission(clientId, userId, Permission.CanAddEmployee))
            {
                throw new Exception("User has not permission to perform this operation");
            }

            if (model == null)
            {
                throw new ArgumentNullException();
            }

            var existingemployee = await _employeeRepository.GetAsync(model.Id);

            if (existingemployee == null)
            {
                throw new Exception("Employee does not exist which you trying to approve");
            }

            //this is using for the set the shift time
            var employeeApprove = new ShiftHistoryModel();

            employeeApprove.EmployeeId = model.Id;
            employeeApprove.ShiftId    = model.ShiftId;
            employeeApprove.StartDate  = DateTime.UtcNow;

            await _shiftHistroyManager.AddAsync(employeeApprove, clientId, userId);

            //this is using for the approve the employee
            var employee = _employeeUpdateMapper.ConvertToDataModel(model);

            employee.UpdatedOn  = DateTime.UtcNow;
            employee.Status     = (int)EmployeeStatus.Active;
            employee.ApprovedBy = userId;

            employee = await _employeeRepository.ApproveEmployeeAsync(employee);

            return(_employeeUpdateMapper.ConvertToModel(employee));
        }
        public async Task <EmployeeResponseModel> UpdateAsync(Guid id, EmployeeUpdateModel model)
        {
            var newEmployee     = _mapper.Map <Employee>(model);
            var updatedEmployee = await _employeeService.UpdateAsync(id, newEmployee);

            if (updatedEmployee.CanAccessTheSystem())
            {
                if (await _accountService.Exists(updatedEmployee.Id))
                {
                    await _accountService.UpdateAsync(updatedEmployee);
                }
                else
                {
                    await _accountService.CreateAsync(updatedEmployee);
                }
            }
            else
            {
                await _accountService.DeleteAsync(updatedEmployee.Id);
            }

            return(_mapper.Map <EmployeeResponseModel>(updatedEmployee));
        }
        public async Task <ActionResult> UpdateEmployee(string companyID, string employeeID, EmployeeUpdateModel employeeUpdateModel)
        {
            var employee = companies[companyID].Employees[employeeID];

            employee.Name   = employeeUpdateModel.Name is null ? employee.Name : employeeUpdateModel.Name;
            employee.Salary = employeeUpdateModel.Salary.HasValue
                ? employeeUpdateModel.Salary.Value
                : employee.Salary;
            return(Ok());
        }
Esempio n. 29
0
        public async Task <ActionResult <Employee> > UpdateEmployee(string companyName, string employeeName, EmployeeUpdateModel employeeUpdateModel)
        {
            var company = companies.FirstOrDefault(c => c.Name == companyName);

            if (company == null)
            {
                return(NotFound());
            }

            var employee = company.Employees.FirstOrDefault(employee => employee.Name == employeeName);

            if (employee == null)
            {
                return(NotFound());
            }

            employee.Name   = employeeUpdateModel.Name;
            employee.Salary = employeeUpdateModel.Salary;
            return(Ok(employee));
        }
        public async Task <ActionResult <int> > ChangeName(int id, [FromBody] EmployeeUpdateModel model)
        {
            var result = await this.employeeService.UpdateEmployee(id, model);

            return(Created(nameof(this.Create), result));
        }