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