public IActionResult AddAnEmployee([FromBody] CreateEmployeeDto createEmployeeDto)
{
if (createEmployeeDto == null)
{
return(BadRequest(ModelState));
}
if (_npRepo.EmployeePIExists(createEmployeeDto.RegimentNumber))
{
ModelState.AddModelError("", "Employee already exists.");
return(StatusCode(404, ModelState));
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
// var ContactInfoObj = _mapper.Map<CreateEmployeeDto, ContactInfo>(createEmployeeDto);
// var employeePIObj = _mapper.Map<CreateEmployeeDto, EmployeePI>(createEmployeeDto);
// employeePIObj.ContactInfo = ContactInfoObj;
// if (!_npRepo.CreateEmployeePI(employeePIObj))
if (!_npRepo.CreateEmployeePI(createEmployeeDto))
{
ModelState.AddModelError("", $"Something went wrong when saving the record {createEmployeeDto.FirstName}");
return(StatusCode(500, ModelState));
}
return(Ok());
}
public async Task <IActionResult> PutEmployees(long id, [FromBody] CreateEmployeeDto createEmployeeDto)
{
if (id != createEmployeeDto.Id)
{
return(BadRequest());
}
var employee = _mapper.Map <Employees>(createEmployeeDto);
employee.UpdatedAt = DateTime.Now;
_context.Employees.Update(employee);
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!EmployeesExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(Ok());
}
public async Task <int> CreateAsync(CreateEmployeeDto request)
{
Require.IsNotNull(request);
try
{
Employee employee = EmployeeMapper.ToEntity(request) ?? throw new ArgumentNullException(nameof(request));
if (await _employeeRepository.AnyAsync(x => x.EmployeeIdNumber.Equals(request.EmployeeIdNumber)))
{
throw new ValidationException($"EmployeeIdNumber : {request.EmployeeIdNumber} already exists.");
}
if (await _employeeRepository.AnyAsync(x => x.Email.Equals(request.Email)))
{
throw new ValidationException($"Email : {request.Email} already exists.");
}
_employeeRepository.Add(employee);
return(await _unitOfWork.SaveChangesAsync());
}
catch (Exception ex)
{
_logger.Log(LogLevel.Error, ex, "Error when EmployeeService.CreateAsync");
throw;
}
}
public EmployeeDto Create(CreateEmployeeDto newEmployee)
{
if (this._employeeRepository.IsExist(newEmployee.FirstName, newEmployee.LastName))
{
throw new Exception("Employee exist.");
}
var employee = new Employee {
FirstName = newEmployee.FirstName,
LastName = newEmployee.LastName,
Rate = newEmployee.Rate,
EmploymentDate = newEmployee.EmploymentDate,
CreationDate = DateTime.UtcNow,
Jobs = newEmployee.Jobs,
};
employee.Id = this._employeeRepository.Save(employee);
var jobs = this._jobRepository.GetList();
return(new EmployeeDto
{
Id = employee.Id,
Rate = employee.Rate,
FirstName = employee.FirstName,
LastName = employee.LastName,
EmploymentDate = employee.EmploymentDate,
CreationDate = employee.CreationDate,
Jobs = jobs.Where(j => employee.Jobs.Contains(j.Id)).Select(job => new JobDto {
Id = job.Id, Title = job.Title
}).ToList()
});
}
public async Task <ActionResult <Employee> > CreateEmployee(CreateEmployeeDto employeeDto)
{
Employee createdEmployee;
try
{
var employee = new Employee()
{
FirstName = employeeDto.FirstName,
LastName = employeeDto.LastName,
Email = employeeDto.Email,
PhoneNumber = employeeDto.PhoneNumber,
DepartmentId = employeeDto.DepartmentId,
PositionId = employeeDto.PositionId
};
createdEmployee = await _employeeService.CreateEmployeeAsync(employee);
}
catch (Exception ex)
{
_logger.LogError(ex.Message);
return(StatusCode(500, new { error = ex.Message }));
}
return(CreatedAtAction("GetEmployeeById", new { id = createdEmployee.Id }, createdEmployee));
}
public async Task <ActionResult> CreateEmployee([FromBody] CreateEmployeeModel model)
{
try
{
bool isExistent = await _departmentService.ExistsAsync(model.DepartmentId);
if (!isExistent)
{
ModelState.AddModelError(nameof(model.DepartmentId), "The Department does not exist.");
return(BadRequest(ModelState));
}
CreateEmployeeDto createEmployeeDto = new CreateEmployeeDto()
{
EmployeeName = model.EmployeeName,
DepartmentId = model.DepartmentId,
DateOfBirth = model.DateOfBirth,
Email = model.Email,
PhoneNumber = model.PhoneNumber
};
await _employeeService.CreateAsync(createEmployeeDto);
return(CreatedAtAction(nameof(GetDetailsById), new { employeeId = 1 }, createEmployeeDto));
}
catch (Exception exception)
{
await _exceptionLogger.LogAsync(exception);
return(StatusCode(StatusCodes.Status500InternalServerError));
}
}
public async Task CreateAsync_Succesfully()
{
// Arrange
var request = new CreateEmployeeDto
{
FirstName = "Steven",
LastName = "Phan",
DepartmentId = 1,
DateOfBirth = DateTime.Now,
AccountNumber = "Account Number ",
AccountTitle = "Mr",
Address1 = "Address 1"
};
_unitOfWorkMock.Setup(x => x.SaveChangesAsync()).ReturnsAsync(1);
var employeeService = new EmployeeService(_employeeRepositoryMock.Object, _unitOfWorkMock.Object, _loggerMock.Object);
// Act
var result = await employeeService.CreateAsync(request);
// Assert
Assert.AreEqual(1, result);
_employeeRepositoryMock.Verify(x => x.Add(It.IsAny <Employee>()), Times.Once);
_unitOfWorkMock.Verify(x => x.SaveChangesAsync(), Times.Once);
}
public static Employee ToEntity(CreateEmployeeDto item)
{
return(new Employee
{
EmployeeIdNumber = item.EmployeeIdNumber,
Phone = item.Phone,
AccountNumber = item.AccountNumber,
Email = item.Email,
AccountTitle = item.AccountTitle,
Address1 = item.Address1,
Address2 = item.Address2,
BankName = item.BankName,
BasicSalary = item.BasicSalary,
City = item.City,
Country = item.Country,
DateOfBirth = item.DateOfBirth,
DepartmentId = item.DepartmentId,
FirstName = item.FirstName,
LastName = item.LastName,
Gender = item.Gender,
JoiningDate = item.JoiningDate,
LeavingDate = item.LeavingDate,
MaritalStatus = item.MaritalStatus,
PlaceOfBirth = item.PlaceOfBirth,
StateProvince = item.StateProvince,
UnpaidLeavePerDay = item.UnpaidLeavePerDay,
SupervisorId = item.SupervisorId,
SystemUserId = item.SystemUserId,
ZipCode = item.ZipCode
});
}
public async Task <IActionResult> CreateEmployee([FromBody] CreateEmployeeModel createEmployeeModel)
{
CreateEmployeeDto createEmployeeDto = _mapper.Map <CreateEmployeeDto>(createEmployeeModel);
await _employeeService.CreateEmployeeAsync(createEmployeeDto);
return(Ok());
}
public Guid CreateUser(CreateEmployeeDto user)
{
var request = new RestRequest("/api/v2.0/users/person", Method.POST, DataFormat.Json);
request.AddJsonBody(user);
return(SendRequest <Identific>(request).Id);
}
public async Task CreateEmployeeAsync_should_create_employee_and_return_jwt_for_employee()
{
// Arrange
using (var server = this.GetServer())
using (var client = this.GetClient(server))
{
var model = new CreateEmployeeDto
{
EmployeeCardId = this.EmployeeCardId,
Email = "*****@*****.**",
MobileNumber = "0123456789",
EmployeeId = Guid.NewGuid().ToString(),
Name = "Integration Test",
Pin = "1234"
};
var json = JsonConvert.SerializeObject(model);
var body = new StringContent(json, Encoding.UTF8, "application/json");
// Act
var response = await client.PostAsync("/api/employees", body);
response.EnsureSuccessStatusCode();
var responseString = JsonConvert.DeserializeObject <String>(await response.Content.ReadAsStringAsync());
// Assert
var handler = new JwtSecurityTokenHandler();
var jwt = handler.ReadJwtToken(responseString);
Assert.Equal(model.EmployeeCardId, jwt.Claims.First(x => x.Type == "sub").Value);
}
}
public async Task CreateEmployee(CreateEmployeeDto input)
{
var @employee = input.MapTo <Employee>();
@employee = Employee.Create(AbpSession.GetTenantId(), input.FullName, input.NicNo, input.EPFNo, input.ETFNo, input.DateOfBirth.Value, input.Gender, input.MaritalStatus, input.Department, input.Designation, input.JobStatus, input.Address, input.MobileNo, input.LandNo, input.EmailAddress, input.EmergencyContactNo, input.EmergencyContactPerson, input.ImagePath);
int i = 0;
await _employeeRepository.InsertAsync(@employee);
}
public void Create(CreateEmployeeDto dto)
{
Employee employee = this.mapper.Map <Employee>(dto);
this.dbContext.Employees.Add(employee);
this.dbContext.SaveChanges();
}
public async Task <EmployeeDto> CreateNewEmployee(CreateEmployeeDto createEmployeeDto)
{
var newEmployee = _createEmployeeMapper.Map(createEmployeeDto);
newEmployee = await _employeeRepository.Insert(newEmployee);
return(_employeeMapper.Map(newEmployee));
}
private void InitialForm()
{
_employeeModel = new CreateEmployeeDto
{
DateOfBirth = DateTime.Now,
JoiningDate = DateTime.Now
};
}
/// <inheritdoc/>
public long CreateEmployee(CreateEmployeeDto employee)
{
var newEmployee = _autoMapper.Map <Employee>(employee);
var newEmployeeId = _employeeRepository.Add(newEmployee);
return(newEmployeeId);
}
public async Task <Response <EmployeeDto> > Update(Guid id, CreateEmployeeDto entityDto)
{
Employee employee = _context.Employees
.Include(u => u.User)
.SingleOrDefault(e => e.Id == id) ??
throw new RestException(HttpStatusCode.NotFound, new { Employee = "Not found" })
;
if (!string.IsNullOrWhiteSpace(entityDto.Password))
{
await _userManager.RemovePasswordAsync(employee.User);
await _userManager.AddPasswordAsync(employee.User, entityDto.Password);
}
employee.User.Email = entityDto.Email;
employee.User.UserName = entityDto.UserName;
employee.User.PhoneNumber = entityDto.Phone;
employee.Salary = entityDto.Salary;
employee.JoiningDate = entityDto.JoiningDate;
employee.Address = entityDto.Address;
employee.UpdatedAt = DateTime.Now;
if (entityDto.Photo != null)
{
if (employee.Photo != null)
{
_photoAccessor.Delete(employee.Photo);
}
string path = _photoAccessor.Add("employees", entityDto.Photo);
employee.Photo = path;
}
var success = await _context.SaveChangesAsync() > 0;
if (success)
{
var employeeDto = _mapper.Map <Employee, EmployeeDto>(employee);
return(new Response <EmployeeDto>
{
Data = employeeDto,
Message = $"Employee {employeeDto.UserName} updated",
Time = DateTime.Now,
IsSuccess = true
});
}
;
throw new Exception("Problem on saving employee");
}
public async Task CreateAsync_Should_Throw_Exception_With_Null_Request()
{
// Arrange
CreateEmployeeDto request = null;
var employeeService = new EmployeeService(_employeeRepositoryMock.Object, _unitOfWorkMock.Object, _loggerMock.Object);
// Act & Assert
Assert.ThrowsAsync <ArgumentNullException>(() => employeeService.CreateAsync(request));
}
public EmployeeVerboseDto CreateEmployee(CreateEmployeeDto newEmployee)
{
_dbContext.ValidateData(newEmployee);
var employee = newEmployee.ToEntity();
_dbContext.Employee.Add(employee);
_dbContext.SaveChanges();
return(employee.ToVerboseDto());
}
public async Task <IActionResult> CreateAsync([FromBody] CreateEmployeeDto request)
{
Logger.LogInformation($"Calling api Create Employee with Json : {JsonConvert.SerializeObject(request)}");
await _employeeService.CreateAsync(request);
Logger.LogInformation("Created successfully.");
return(Ok(await Result.SuccessAsync("Created successfully.")));
}
public async Task <IActionResult> Post([FromBody] CreateEmployeeDto emplyeeDto)
{
var result = await _employeeService.Create(emplyeeDto);
if (!_employeeService.Success())
{
return(BadRequest(_employeeService.Errors));
}
return(Ok(result));
}
public async Task <IActionResult> GetAllEmployee(Guid id)
{
try
{
var employee = await _db.Employees.FindSingleByAsync(w => w.Id.Equals(id));
if (employee == null)
{
return(NotFound());
}
var person = await _db.Persons.FindSingleByAsync(w => w.Id.Equals(employee.PersonId));
var contact = await _db.Contacts.FindSingleByAsync(w => w.PersonId.Equals(person.Id));
var address = await _db.Address.FindSingleByAsync(w => w.Id.Equals(person.AddressId));
var city = await _db.Cities.FindSingleByAsync(w => w.Id.Equals(address.CityId));
var country = await _db.Countries.FindSingleByAsync(w => w.Id.Equals(city.CountryId));
var employeeDto = new CreateEmployeeDto();
employeeDto.Id = employee.Id;
employeeDto.PositionId = employee.PositionId;
employeeDto.FirstName = person.FirstName;
employeeDto.LastName = person.LastName;
employeeDto.Gender = person.Gender;
employeeDto.EmplNumber = employee.EmplNumber;
employeeDto.Salary = employee.Salary.ToString();
employeeDto.HireDate = employee.HireDate.ToString();
employeeDto.Supervisor = employee.Supervisor;
employeeDto.DateOfBirth = person.DateOfBirth.ToString();
employeeDto.Email = contact.Email;
employeeDto.PhoneNumber = contact.PhoneNumber;
employeeDto.MobileNumber = contact.MobileNumber;
employeeDto.EmailEmployee = employee.EmailEmployee;
employeeDto.StreetName = address.StreetName;
employeeDto.HouseNumber = address.HouseNumber.ToString();
employeeDto.Municipality = address.Municipality;
employeeDto.Sector = address.Sector;
employeeDto.City = city.Name;
employeeDto.Country = country.Name;
return(Ok(employeeDto));
}
catch (Exception ex)
{
_logger.LogError(ex, "Error obteniendo una empleado by Id");
return(StatusCode(500));
}
}
public async Task <ActionResult <int> > Create([FromBody] CreateEmployeeDto model)
{
var employee = await _employeeDao.GetByPersonalIdAsync(model.PersonalId);
if (employee != null)
{
return(Conflict($"Employee with personalId {model.PersonalId} already exists"));
}
return(Ok(await _employeeDao.CreateAsync(model.GetEmployee())));
}
public async Task <IActionResult> Create(CreateEmployeeDto item)
{
if (!ModelState.IsValid)
{
return(BadRequest(new ModelStateResult(ModelState)));
}
var createEmployeeResultDto = await _employeesService.Create(item, UserId);
return(Ok(createEmployeeResultDto));
}
public int Create(CreateEmployeeDto dto)
{
var employee = new Employee
{
Name = dto.Name,
};
var parent = _context.Industries.Find(dto.IndustryId);
parent.Employees.Add(employee);
_context.SaveChanges();
return(employee.Id);
}
public async Task <IActionResult> CreateNewEmployee([FromBody] CreateEmployeeDto createEmployeeDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var newEmployeeDto = await _employeeService.CreateNewEmployee(createEmployeeDto);
return(Ok(newEmployeeDto));
}
public async Task <ActionResult <Employees> > PostEmployees([FromBody] CreateEmployeeDto createEmployeeDto)
{
var employee = _mapper.Map <Employees>(createEmployeeDto);
employee.Status = 1;
employee.UpdatedAt = DateTime.Now;
employee.CreatedAt = DateTime.Now;
_context.Employees.Add(employee);
await _context.SaveChangesAsync();
return(Ok());
}
public IActionResult Register(RegisterEmployeeInputModel model)
{
if (!ModelState.IsValid)
{
return(RedirectToAction("Error", "Register"));
}
CreateEmployeeDto employee = this.mapper.Map <CreateEmployeeDto>(model);
this.employeeService.Create(employee);
return(RedirectToAction("All"));
}
public async Task <EmployeeDto> CreateAsync(CreateEmployeeDto input)
{
CheckBeforeCreate(input);
var employee = ObjectMapper.Map <Employee>(input);
//Create User
var user = await CreateAccountForEmployeeAsync(input);
employee.UserId = user.Id;
await _repository.InsertAsync(employee);
return(ObjectMapper.Map <EmployeeDto>(employee));
}
public EmployeeDto Create(CreateEmployeeDto input)
{
var employee = _mapper.Map <CreateEmployeeDto, Employee>(input);
// Only Course Coordinator has the permission to have 1 CourseId
if (input.Designation == Designation.CourseCoordinator)
{
employee.CourseId = employee.CourseId;
employee.SubjectId = null;
}
else
{
employee.CourseId = null;
}
// Lecturer can have the subject
if (input.Designation == Designation.Lecturer)
{
employee.SubjectId = employee.SubjectId;
employee.CourseId = null;
}
else
{
employee.SubjectId = null;
}
// Admin / General Manager
if (input.Designation == Designation.GeneralManager)
{
employee.SubjectId = null;
employee.CourseId = null;
}
employee.ApplicationUser = new ApplicationUser
{
UserName = input.Email,
Email = input.Email,
PasswordHash = Crypto.HashPassword(input.Password),
SecurityStamp = Guid.NewGuid().ToString("D"),
LockoutEnabled = true,
IsStudent = false,
Designation = employee.Designation
};
var createdEmployee = _context.Employees.Add(employee);
_context.SaveChanges();
return(_mapper.Map <Employee, EmployeeDto>(createdEmployee));
}
