public async Task <IActionResult> CreateEmployeeForCompany(Guid companyId, [FromBody] EmployeeForCreationDto employee) { //validation of model done by validation filter //find company var company = await _repository.Company.GetCompanyAsync(companyId, trackChanges : false); if (company == null) { _logger.LogInfo($"Company with id: {companyId} doesn't exist in the database."); return(NotFound()); } //save employee var employeeEntity = _mapper.Map <Employee>(employee); _repository.Employee.CreateEmployeeForCompany(companyId, employeeEntity); await _repository.SaveAsync(); //create EmployeeDto and return var employeeToReturn = _mapper.Map <EmployeeDto>(employeeEntity); return(CreatedAtRoute("GetEmployeeForCompany", new { companyId, id = employeeToReturn.Id }, employeeToReturn)); }
public IActionResult CreateEmployee(Guid companyId, [FromBody] EmployeeForCreationDto employee) { var company = _repository.Company.GetCompany(companyId, false); if (company == null) { _logger.LogInfo($"Company with id {companyId} doesn't exits"); return(NotFound()); } if (employee == null) { _logger.LogError("EmployeeForCreationDto object sent from the client is null"); return(BadRequest("EmployeeForCreationDto object is null")); } var employeeEntity = _mapper.Map <Employee>(employee); _repository.Employee.CreateEmployee(companyId, employeeEntity); _repository.Save(); var employeeToReturn = _mapper.Map <EmployeeDto>(employeeEntity); return(CreatedAtRoute("GetEmployeeForCompany", new { companyId, id = employeeToReturn.Id }, employeeToReturn)); }
public async Task <ActionResult <EmployeeDto> > AddEmployee([FromBody] EmployeeForCreationDto employeeForCreation) { var validationResults = new EmployeeForCreationDtoValidator().Validate(employeeForCreation); validationResults.AddToModelState(ModelState, null); if (!ModelState.IsValid) { return(BadRequest(new ValidationProblemDetails(ModelState))); //return ValidationProblem(); } var employee = _mapper.Map <Employee>(employeeForCreation); await _employeeRepo.AddEmployee(employee); var saveSuccessful = await _employeeRepo.SaveAsync(); if (saveSuccessful) { var employeeFromRepo = await _employeeRepo.GetEmployeeAsync(employee.Id); var employeeDto = _mapper.Map <EmployeeDto>(employeeFromRepo); var response = new Response <EmployeeDto>(employeeDto); return(CreatedAtRoute("GetEmployee", new { employeeDto.Id }, response)); } return(StatusCode(500)); }
public IActionResult CreateEmployee([FromBody] EmployeeForCreationDto employee) { try { if (employee == null) { _logger.LogError("employee object sent from client is null."); return BadRequest("employee object is null"); } if (!ModelState.IsValid) { _logger.LogError("Invalid employee object sent from client."); return BadRequest("Invalid model object"); } var employeeEntity = _mapper.Map<Employee>(employee); _repository.Employee.CreateEmployee(employeeEntity); _repository.Save(); var createdEmployee = _mapper.Map<EmployeeDto>(employeeEntity); return CreatedAtRoute("EmployeeById", new { id = createdEmployee.EmployeeId }, createdEmployee); } catch (Exception ex) { _logger.LogError($"Something went wrong inside CreateEmployee action: {ex.InnerException.Message}"); return StatusCode(500, "Internal server error"); } }
public IActionResult CreateEmployeeForCompany(Guid companyId, [FromBody] EmployeeForCreationDto employee) { if (employee == null) { _logger.LogError("EmployeeForCreationDto object sent form client is null."); return BadRequest("EmployeeForCreationDto object is null."); } var company = _repo.Company.GetCompany(companyId, trackChanges: false); if (company == null) { _logger.LogInfo($"Company with id: { companyId } doesnt exit in the database."); return NotFound(); } var employeeEntity = _mapper.Map<Employee>(employee); _repo.Employee.CreateEmployeeForCompany(companyId, employeeEntity); _repo.Save(); var employeeToReturn = _mapper.Map<EmployeeDto>(employeeEntity); return CreatedAtRoute("GetEmployeeForCompany", new { companyId, id = employeeToReturn.Id }, employeeToReturn); }
public async Task <IActionResult> CreateEmployeeForCompany(Guid companyId, [FromBody] EmployeeForCreationDto employee) { if (employee == null) { logger.LogError("EmployeeForCreationDto object sent from client is null."); return(BadRequest("EmployeeForCreationDto object is null")); } if (!ModelState.IsValid) { logger.LogError("Invalid model state for EmployeeForCreationDto object."); return(UnprocessableEntity(ModelState)); } var company = await repository.Company.GetCompanyAsync(companyId, trackChanges : false); if (company == null) { logger.LogInfo($"Company with id {companyId} doesn't exist in the database."); return(NotFound()); } var employeeEntity = mapper.Map <Employee>(employee); repository.Employee.CreateEmployeeForCompany(companyId, employeeEntity); await repository.SaveAsync(); var employeeToReturn = mapper.Map <EmployeeDto>(employeeEntity); return(CreatedAtRoute("GetEmployee", new { companyId, id = employeeToReturn.Id }, employeeToReturn)); }
public void CreateEmployeeForCompany_ValidInputCreatesEmployeeyAndReturnsAnOkResult_WithAnEmployee() { // Arrange var existingCompany = SeedTestData.GetTestCompany(); Guid companyId = existingCompany.Id; var testEmployee = SeedTestData.GetTestEmployee(); mockRepo.Setup(repo => repo.Company.GetCompany(companyId, false)).Returns(existingCompany).Verifiable(); mockRepo.Setup(repo => repo.Employee.CreateEmployeeForCompany(companyId, It.IsAny <Employee>())) .Verifiable(); var controller = new EmployeesController(mockRepo.Object, _mapper); EmployeeForCreationDto newEmployeeDto = new EmployeeForCreationDto() { Name = testEmployee.Name, Age = testEmployee.Age, Position = testEmployee.Position }; // Act var result = controller.CreateEmployeeForCompany(companyId, newEmployeeDto); // Assert Assert.IsInstanceOf <OkObjectResult>(result); var okResult = result as OkObjectResult; Assert.That(okResult.Value, Is.TypeOf <Employee>()); Employee resultEmp = okResult.Value as Employee; Assert.AreEqual(resultEmp.Name, newEmployeeDto.Name); Assert.AreEqual(resultEmp.Age, newEmployeeDto.Age); Assert.AreEqual(resultEmp.Position, newEmployeeDto.Position); mockRepo.Verify(repo => repo.Company.GetCompany(companyId, false), Times.Once); mockRepo.Verify(); }
public IActionResult CreateEmployee(Guid companyId, [FromBody] EmployeeForCreationDto employee) { if (employee == null) { var message = ErrorMessages.EmployeeIsNull; _logger.LogError(message); return(BadRequest(message)); } var company = _companyService.GetCompanyById(companyId, trackChanges: false); if (company == null) { var message = string.Format(ErrorMessages.CompanyNotFound, companyId); _logger.LogInfo(message); return(NotFound(message)); } var createdEmployee = _employeeService.CreateEmployee(employee, companyId); return(CreatedAtRoute("GetEmployeeByCompanyId", new { companyId, employeeId = createdEmployee.Id }, createdEmployee)); }
public async Task <IActionResult> Post([FromBody] EmployeeForCreationDto EmployeeDto) { var Employee = _mapper.Map <Employee>(EmployeeDto); _ = await _EmployeeService.Insert(Employee); return(Response(Employee.EmployeeId)); }
public async Task <IActionResult> CreateEmployeeForCompany(Guid companyId, EmployeeForCreationDto employee) { var employeeEntity = _mapper.Map <Employee>(employee); _repository.Employee.CreateEmployeeForCompany(companyId, employeeEntity); await _repository.SaveAsync(); var employeeReturn = _mapper.Map <EmployeeDto>(employeeEntity); return(CreatedAtRoute("GetEmployeeForCompanyById", new { id = employeeEntity.Id, CompanyId = companyId }, employeeReturn)); }
public async Task <IActionResult> CreateEmployee(Guid companyId, [FromBody] EmployeeForCreationDto employee) { var employeeEntity = _mapper.Map <Employee>(employee); _repository.Employee.CreateEmployeeForCompany(companyId, employeeEntity); await _repository.SaveAsync(); var employeeToReturn = _mapper.Map <EmployeeDto>(employeeEntity); return(Created("Employees", employeeToReturn)); }
public async Task <EmployeeDto> CreateAsync(EmployeeForCreationDto employeeForCreation) { var employee = _mapper.Map <Employee>(employeeForCreation); employee = await _userService.BindAssetWithUserAsync(CurrentUserId, employee); _repositoryManager.Employee.CreateEmployee(employee); await _repositoryManager.SaveAsync(); return(_mapper.Map <EmployeeDto>(employee)); }
public async Task <IActionResult> CreateEmployeeForCompany(Guid companyId, [FromBody] EmployeeForCreationDto employee) { //------------- The commented code below is replaced by the ActionFilter called as an attribute above ---------- //Check if request contains NULL values //if (employee == null) //{ // _logger.LogError("EmployeeForCreationDto object sent from client is null."); // return BadRequest("EmployeeForCreationDto object is null"); //} ////Suppress the BadRequest error when the ModelState is invalid //if (!ModelState.IsValid) //{ // _logger.LogError("Invalid model state for the EmployeeForCreationDto object"); // //ModelState.AddModelError(string key, string errorMessage); // return UnprocessableEntity(ModelState); //} //Check to see that company with such Guid exists var company = await _repository.Company.GetCompanyAsync(companyId, trackChanges : false); if (company == null) { _logger.LogInfo($"Company with id: {companyId} doesn't exist in the database."); return(NotFound()); } //var employeeEntity = _mapper.Map<Employee>(employee); var employeeEntity = new Employee { Name = employee.Name, Age = employee.Age, Position = employee.Position }; _repository.Employee.CreateEmployeeForCompany(companyId, employeeEntity); await _repository.SaveAsync(); var employeeToReturn = new EmployeeDto { Id = employeeEntity.Id, Name = employeeEntity.Name, Age = employeeEntity.Age, Position = employeeEntity.Position, }; return(CreatedAtRoute("GetEmployeeForCompany", new { companyId, id = employeeToReturn.Id }, employeeToReturn)); }
public async Task <IActionResult> CreateEmployee(EmployeeForCreationDto employeeForCreationDto) { var empToCreate = _mapper.Map <Employee> (employeeForCreationDto); _repo.Add(empToCreate); if (await _repo.SaveAll()) { var empToReturn = _mapper.Map <EmployeeForDetailDto> (empToCreate); return(CreatedAtRoute("GetEmployee", new { id = empToCreate.Id }, empToReturn)); } throw new Exception("Creating the employee failed on save"); }
public EmployeeDto CreateEmployee(EmployeeForCreationDto employee, Guid companyId) { var employeeEntity = _mapper.Map <Employee>(employee); employeeEntity.CompanyId = companyId; _employeeRepository.CreateEmployee(employeeEntity); _repositoryManager.Save(); var employeeToReturn = _mapper.Map <EmployeeDto>(employeeEntity); return(employeeToReturn); }
public ActionResult <EmployeeDto> CreateEmployeeForCompany(Guid companyId, EmployeeForCreationDto employeeForCreationDto) { if (repository.Company.GetCompany(companyId, false) == null) { return(NotFound()); } var emp = mapper.Map <Employee>(employeeForCreationDto); emp.Id = Guid.NewGuid(); repository.Employee.CreateEmployeeForCompany(companyId, emp); repository.Save(); return(CreatedAtRoute(nameof(GetCompanyEmployee), new { companyId, id = emp.Id }, mapper.Map <EmployeeDto>(emp))); }
public async Task <IActionResult> AddEmployee(EmployeeForCreationDto employeeForCreationDto) { var employee = _mapper.Map <Employee>(employeeForCreationDto); _repo.Add(employee); if (await _repo.SaveAll()) { var employeeToReturn = _mapper.Map <EmployeeForReturnDto>(employee); return(CreatedAtRoute("GetEmployee", new { id = employee.Id }, employeeToReturn)); } return(BadRequest("Could not add the employee")); }
public void CreateEmployeeForCompany__InValidInputNull_ReturnsBadRequestObjectResult() { // Arrange var existingCompany = SeedTestData.GetTestCompany(); Guid companyId = existingCompany.Id; var controller = new EmployeesController(mockRepo.Object, _mapper); EmployeeForCreationDto newEmployeeDto = null; // Act var result = controller.CreateEmployeeForCompany(companyId, newEmployeeDto); // Assert Assert.IsInstanceOf <BadRequestObjectResult>(result); mockRepo.Verify(repo => repo.Employee.CreateEmployeeForCompany(companyId, It.IsAny <Employee>()), Times.Never); }
public IActionResult CreateEmployee([FromBody] EmployeeForCreationDto employee) { if (!ModelState.IsValid) { return(BadRequest()); } var employeeEntity = _mapper.Map <Employee>(employee); _repository.AddEmployee(employeeEntity); _repository.Save(); var entityToReturn = _mapper.Map <EmployeeDto>(employeeEntity); return(CreatedAtRoute("GetEmployee", new { employeeId = entityToReturn.Id }, entityToReturn)); }
private Employee MapRelatedCollectionOnCreation(EmployeeForCreationDto employee) { var employeeEntity = _mapper.Map <Employee>(employee); var mappedEmployeeSkills = new List <EmployeeSkill>(); employee.EmployeeSkills.ToList().ForEach(es => mappedEmployeeSkills.Add(new EmployeeSkill() { SkillId = _unitOfWork.Skills.GetSkill(es.SkillId).Id })); mappedEmployeeSkills.ForEach(es => employeeEntity.EmployeeSkills.Add(es)); var jobId = _unitOfWork.Jobs.GetJob(employee.JobId).Id; employeeEntity.JobId = jobId; return(employeeEntity); }
public IActionResult CreateEmployee(EmployeeForCreationDto employee) { var employeeEntity = MapRelatedCollectionOnCreation(employee); if (_unitOfWork.Employees.EmployeeExists(employeeEntity)) { return(Conflict(new { message = $"This Employee already exists in the database!" })); } _unitOfWork.Employees.AddEmployee(employeeEntity); _unitOfWork.Complete(); var employeeToReturn = _mapper.Map <EmployeeFullDto>(employeeEntity); return(CreatedAtRoute("GetEmployee", new { employeeId = employeeToReturn.Id }, employeeToReturn)); }
public async Task <IActionResult> CreateEmployeeForCompany(Guid companyId, [FromBody] EmployeeForCreationDto employee) { var company = await _repositoryManager.Company.GetCompanyAsync(companyId, trackChanges : false); if (company == null) { _logger.LogInfo($"Company with id: {companyId} doesn't exist in the database"); return(NotFound()); } var employeeEntity = _mapper.Map <Employee>(employee); _repositoryManager.Employee.CreateEmployeeForCompany(companyId, employeeEntity); await _repositoryManager.SaveAsync(); var employeeToReturn = _mapper.Map <EmployeeDto>(employeeEntity); return(CreatedAtRoute("GetEmployeeForCompany", new { companyId, id = employeeToReturn.Id }, employeeToReturn)); }
public IActionResult CreateEmployeeForCompany(Guid companyId, [FromBody] EmployeeForCreationDto employeeDto) { if (employeeDto == null) { return(BadRequest("employeeDto object is null")); } var company = _repositoryManager.Company.GetCompany(companyId, false); if (company == null) { return(NotFound()); } var employee = _mapper.Map <Employee>(employeeDto); _repositoryManager.Employee.CreateEmployeeForCompany(companyId, employee); _repositoryManager.Save(); return(Ok(employee)); }
public IActionResult CreateEmployee([FromBody] EmployeeForCreationDto employee) { if (employee == null) { return(BadRequest()); } var employeeEntity = Mapper.Map <Employee>(employee); _pgRepository.AddEmployee(employeeEntity); if (!_pgRepository.Save()) { throw new Exception("Creating an employee failed on save."); } var employeeToReturn = Mapper.Map <EmployeeDto>(employeeEntity); return(CreatedAtRoute("GetEmployee", new { id = employeeToReturn.Id }, employeeToReturn)); }
public async Task <IActionResult> CreateEmployee(EmployeeForCreationDto employeeDto) { if (employeeDto == null) { return(BadRequest()); } if (!ModelState.IsValid) { return(new UnprocessableObjectResult(ModelState)); } var dto = await _employeeService.CreateEmployeeAsync(_mapper.Map <EmployeeDto>(employeeDto)); if (dto.Id == 0) { return(Conflict()); } return(Ok()); //return CreatedAtRoute(); }
public async Task <IActionResult> AddEmployee(int userId, EmployeeForCreationDto employeeForCreation) { if (userId != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value)) { return(Unauthorized()); } var employee = _mapper.Map <User>(employeeForCreation); if (await _authRepo.UserExistsInOrganization(employeeForCreation.Email, userId)) { return(BadRequest("Email already exists")); } if (employeeForCreation.Password != employeeForCreation.ConfirmPassword) { return(BadRequest("Passwords do not match!")); } await _authRepo.RegisterEmployee(employee, employeeForCreation.Password, userId); return(StatusCode(201)); }
public IActionResult CreateEmployee([FromBody] EmployeeForCreationDto employee) { if (employee == null) { return(BadRequest()); } if (!ModelState.IsValid) { return(new UnprocessableEntityObjectResult(ModelState)); } var employeeEntity = Mapper.Map <Employee>(employee); _appRepository.AddEmployee(employeeEntity); if (!_appRepository.Save()) { throw new Exception("Employee creation failed on save."); } var employeeToReturn = Mapper.Map <EmployeeDto>(employeeEntity); return(CreatedAtRoute("GetEmployee", new { empId = employeeToReturn.EmpId }, employeeToReturn)); }
public async Task <IActionResult> CreateEmployeeForCompany([FromBody] EmployeeForCreationDto employee) { #region использование валидации /*Чтобы вернуть 422 вместо 400, первое, что нам нужно сделать, это подавить * BadRequest ошибка, когда ModelState является недействительным. * Мы собираемся сделать это, добавив этот код в Startup класс в ConfigureServices метод: * services.Configure<ApiBehaviorOptions>(options => * { * options.SuppressModelStateInvalidFilter = true; * }); */ #endregion// проверяется в атрибуте // перенанесно в ValidateModelAttribute /* if (!ModelState.IsValid) * { * ModelState.AddModelError("Age", "Хуй");// необязательный метод. Можно к определенным полям добавлять пользовательское сообщение об ошибке * ModelState.AddModelError("Name", "Хуй");// необязательный метод. Можно к определенным полям добавлять пользовательское сообщение об ошибке * _logger.LogError("Invalid model state for the EmployeeForCreationDto object"); * return UnprocessableEntity(ModelState); * }*/ try { // перенанесно в ValidateModelAttribute /*if (employee == null) * { * _logger.LogError("EmployeeForCreationDto object sent from client is null."); * return BadRequest("EmployeeForCreationDto object is null"); * }*/ var companyall = (await _wrapper.Company?.GetAllCompaniesSortByNameAsunc(false)).ToList(); var companyByName = companyall?.Where(x => x.Name.Equals(employee.CompanyName))?.SingleOrDefault(); if (companyByName == null) { _logger.LogError("EmployeeForCreationDto object sent from client is null."); return(BadRequest("EmployeeForCreationDto object is null")); } var company = await _wrapper.Company.GetCompanyAsync(companyByName.Id, false); if (company == null) { _logger.LogInfo($"Company with id: {companyByName.Id} doesn't exist in the database."); return(NotFound()); } var employeeEntity = _mapper.Map <Employee>(employee); _wrapper.Employee.CreateEmployeeForCompany(companyByName.Id, employeeEntity); await _wrapper.SaveAsync(); var employeeToReturn = _mapper.Map <EmployeeDto>(employeeEntity); return(CreatedAtRoute(routeValues: new { id = employeeToReturn.Id }, value: employeeToReturn)); } catch (Exception ex) { _logger.LogError($"При при попытке добавить пользователя {employee.Name} произошла ошибка. Подробности" + $"{ex.Message}, {ex.Data}, {ex.TargetSite}"); return(BadRequest($"При попвтке создания организации с с названием {employee.Name} произошла ошибка. Подробности" + $"{ex.Message}, {ex.Data}, {ex.TargetSite}")); } }
public async Task <IActionResult> CreateEmployee(EmployeeForCreationDto creationDto) { var result = await _employeeService.CreateEmployeeAsync(creationDto); return(StatusCode((int)result.Code, result)); }
public async Task <ApiResult <string> > CreateEmployeeAsync(EmployeeForCreationDto creationDto) { try { if (creationDto != null) { var checkRole = await _roleManager.FindByIdAsync(creationDto.DefaultRoleId.ToString("D")); if (checkRole == null) { _logger.LogError($"Mã quyền {creationDto.DefaultRoleId} không tồn tại"); return(new ApiResult <string>(HttpStatusCode.BadRequest, $"Mã quyền {creationDto.DefaultRoleId} không tồn tại")); } var checkEmail = await _userManager.FindByEmailAsync(creationDto.Email); if (checkEmail != null) { return(new ApiResult <string>(HttpStatusCode.BadRequest, $"Email: {creationDto.Email} đã được sử dụng")); } var countNumber = await _context.Employees.CountAsync(); var generateId = IdentifyGenerator.GenerateEmployeeId(countNumber + 1); var employee = ObjectMapper.Mapper.Map <EmployeeForCreationDto, Data.Entities.Employee>(creationDto); employee.Id = generateId; employee.IsDelete = false; await _context.Employees.AddAsync(employee); await _context.SaveChangesAsync(); var newAccount = new AppUser(generateId.ToLower()) { PhoneNumber = creationDto.PhoneNumber, Email = creationDto.Email }; var result = await _userManager.CreateAsync(newAccount, _configuration["DefaultPassword"]); if (!result.Succeeded) { _logger.LogError("Có lỗi khi tạo tài khoản cho nhân viên"); return(new ApiResult <string>(HttpStatusCode.InternalServerError, "Có lỗi khi tạo tài khoản cho nhân viên")); } var createdEmployee = await _context.Employees.Where(x => x.Id == generateId).SingleOrDefaultAsync(); if (createdEmployee != null) { var createdAccount = await _userManager.FindByNameAsync(newAccount.UserName); createdEmployee.AppuserId = createdAccount.Id; await _context.SaveChangesAsync(); await _userManager.AddToRoleAsync(createdAccount, checkRole.Name); return(new ApiResult <string>() { Code = HttpStatusCode.OK, ResultObj = generateId, Message = "Tạo mới nhân viên thành công" }); } _logger.LogError($"Nhân viên có mã {generateId} chưa được tạo."); return(new ApiResult <string>(HttpStatusCode.InternalServerError, $"Nhân viên có mã {generateId} chưa được tạo.")); } return(new ApiResult <string>(HttpStatusCode.BadRequest, $"Employee is null")); } catch (Exception e) { _logger.LogError($"Có lỗi khi tạo nhân viên, lỗi: {e.Message}"); return(new ApiResult <string>(HttpStatusCode.InternalServerError, "Có lỗi khi tạo tài khoản cho nhân viên")); } }