public async Task <ActionResult <Employee> > CreateEmployeeAsync(Employee employeeToCreate)
{
try
{
if (employeeToCreate == null)
{
return(BadRequest());
}
if (await _employeeRepository.GetEmployeeByEmailAsync(employeeToCreate.Email) != null)
{
ModelState.AddModelError("email", "Employee email already in use");
return(BadRequest(ModelState));
}
var createdEmployee = await _employeeRepository.AddEmployeeAsync(employeeToCreate);
//return Ok(createdEmployee.ToJToken()); // will work
//return CreatedAtAction(nameof(GetEmployeeByIdAsync), new { id = createdEmployee.Id }, createdEmployee.ToJToken()); // won't work
return(CreatedAtRoute(new { id = createdEmployee.Id }, createdEmployee.ToJToken())); // works
}
catch (Exception ex)
{
return(StatusCode(StatusCodes.Status500InternalServerError, $"Error retrieving data from the database ({ex.Message})"));
}
}
public async Task <IActionResult> AddEmployee([FromBody] Employee emp)
{
if (ModelState.IsValid)
{
try
{
var empId = await employeeRepository.AddEmployeeAsync(emp);
if (empId > 0)
{
return(Ok(empId));
}
else
{
return(NotFound());
}
}
catch (Exception)
{
return(BadRequest());
}
}
return(BadRequest());
}
public async Task <ActionResult <EmployeeDto> > CreateEmployeeForCompany(Guid companyId, EmployeeAddDto employee)
{
if (!await companyRepository.Where(t => t.Id.Equals(companyId)).AnyAsync())
{
return(NotFound());
}
var entity = mapper.Map <Employee>(employee);
var result = await employeeRepository.AddEmployeeAsync(companyId, entity);
var resultDto = mapper.Map <EmployeeDto>(result);
return(CreatedAtRoute(nameof(GetEmployeeForCompany),
new { companyId, employeeId = resultDto.Id },
resultDto));
}
public async Task <ServiceResponseModel <Employee> > AddEmployeeAsync(AddEmployeeModel addEmployee)
{
var newEmployee = await _employeeRepository.AddEmployeeAsync(addEmployee);
var addNewEmployeeStatus = newEmployee.Id > 0 ? ServiceStatusCode.Success : ServiceStatusCode.Error;
return(ServiceResponseUtil.GetServiceResponse(addNewEmployeeStatus, newEmployee));
}
public async Task <IActionResult> PostEmployee([FromBody] Employee employee)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
await _service.AddEmployeeAsync(employee);
return(CreatedAtAction("GetEmployee", new { id = employee.Id }, employee));
}
public async Task <ActionResult <Employee> > AddEmployee([FromBody] Employee employee)
{
var query = await _repository.AddEmployeeAsync(employee);
if (query != null)
{
await _repository.CommitAsync();
}
return(query);
}
public async Task <int> Handle(CreateEmployeeCommand request, CancellationToken cancellationToken)
{
/*
* {
* "id": 1,
* "name": "Benjamin",
* "partner": {
* "id": 4
* }
* }
*/
var employee = Employee.CreateEmployee(request.Name, request.Partner, _employeePartnerChecker);
return(await _employeeRepository.AddEmployeeAsync(employee));
}
public async Task <IActionResult> CreateEmployee([FromBody] Employee employee)
{
if (employee == null)
{
return(BadRequest());
}
if (employee.FirstName == string.Empty || employee.LastName == string.Empty)
{
ModelState.AddModelError("Name/FirstName", "The name or first name shouldn't be empty");
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var createdEmployee = await _employeeRepository.AddEmployeeAsync(employee);
return(Created("employee", createdEmployee));
}
public async Task CanAdd()
{
_logger.LogInformation("CanAdd");
var employee = new Employee
{
EmployeeId = 9999,
FirstName = "TesterFirstName",
LastName = "TesterLastName",
BirthDate = new DateTime(2001, 12, 16),
CompanyId = 1,
DepartmentId = 1,
Created = DateTime.UtcNow,
Modified = DateTime.UtcNow
};
var repoEmployee = await _employeeRepository.AddEmployeeAsync(employee, true).ConfigureAwait(false);
var user = new User
{
EmployeeId = 9999,
Username = "******",
Password = "******",
Token = string.Empty
};
var addedUser = await _userRepository.AddUserAsync(user, true).ConfigureAwait(false);
Assert.Equal("tester", addedUser.Username);
var repoUser = await _userRepository.GetUserAsync(user.EmployeeId, true).ConfigureAwait(false);
_userRepository.Remove(repoUser);
await _userRepository.SaveAsync().ConfigureAwait(false);
_employeeRepository.Remove(repoEmployee);
await _employeeRepository.SaveAsync().ConfigureAwait(false);
}
public async Task <ActionResult <Employee> > AddEmployee(Employee employee)
{
return(await _employeeRepository.AddEmployeeAsync(employee));
}
public async Task <IActionResult> AddEmployee([FromBody] Employee employee)
{
await _repo.AddEmployeeAsync(employee);
return(Ok());
}
Task <EmployeeModel> IEmployeeUsecase.AddEmployeeAsync(EmployeeModel employee)
{
return(_employeeRepository.AddEmployeeAsync(employee));
}
/// <summary>
/// Adds an employee to the database
/// </summary>
/// <param name="employee">The employee to add</param>
/// <returns>An updated employee that has reflects what is in the database</returns>
public async Task <Employee> AddEmployeeAsync(Employee employee)
{
_discountBL.ApplyDiscounts(employee);
return(await _employeeRepository.AddEmployeeAsync(employee));
}
public async Task <int> AddEmployeeAsync(Employee employee)
{
return(await _employeeRepository.AddEmployeeAsync(employee));
}
public async Task <Employee> CreateEmployeeAsync(Employee employee)
{
var id = await _employeeRepository.AddEmployeeAsync(employee);
return(await _employeeRepository.GetEmployeeAsync(id));
}
public async Task CanAddEmployees(Employee employee)
{
var repoEmployee = await _employeeRepository.AddEmployeeAsync(employee).ConfigureAwait(false);
Assert.True(repoEmployee.EmployeeId > 0);
}
