public async Task <ActionResult> CreateEmployeeAsync(EmployeeCreateDTO employeeDto)
{
var newEmployee = _mapper.Map <Employee>(employeeDto);
var createdEmployee = await _employeeService.AddEmployeeAsync(newEmployee);
return(Ok(createdEmployee));
}
public async Task <IActionResult> Register(EmployeeCreateDTO employeeDTO)
{
var validatedFname = employeeDTO.FirstName.FirstCharToUpper();
var validatedLname = employeeDTO.LastName.FirstCharToUpper();
var validatedFullName = validatedFname + ' ' + validatedLname;
var validatedEmail = employeeDTO.Email.ToLower();
if (await _repo.EmployeeExists(validatedFullName, validatedEmail))
{
return(BadRequest("Employee fullname or email already exists"));
}
// new employee schema
var employeeToCreate = new Employee
{
FirstName = validatedFname,
LastName = validatedLname,
FullName = validatedFullName,
Email = validatedEmail
};
var createdUser = await _repo.Register(employeeToCreate, employeeDTO.Password);
// return CreatedAtRoute()
return(StatusCode(201));
}
public async Task <IActionResult> Create([FromBody] EmployeeCreateDTO employeeDTO)
{
try
{
_logger.LogInfo($"Employee submission attempted.");
if (employeeDTO == null)
{
_logger.LogWarn($"Empty Request was submitted.");
return(BadRequest(ModelState));
}
if (!ModelState.IsValid)
{
_logger.LogWarn($"Employee Data was Invalid.");
return(BadRequest(ModelState));
}
var employee = _mapper.Map <Employee>(employeeDTO);
var isSuccess = await _employeeRepository.Create(employee);
if (!isSuccess)
{
return(InternalError($"Employee creation failed."));
}
_logger.LogInfo("Employee created");
return(Created("Create", new { employee }));
}
catch (Exception e)
{
return(InternalError($"{e.Message} - {e.InnerException}"));
}
}
public async Task <IdentityResult> CreateAsync(EmployeeCreateDTO createModel)
{
if (createModel == null)
{
return(IdentityResult.Failed(new IdentityError
{
Code = string.Empty,
Description = "Please fill in the required fields"
}));
}
var user = new ApplicationUser
{
UserName = createModel.Email,
Email = createModel.Email,
Address = "",
FirstName = createModel.FirstName,
MiddleName = createModel.MiddleName,
LastName = createModel.LastName,
EmailConfirmed = true
};
IEnumerable <string> staffRoles = await StaffRoles();
List <string> availableRoles = createModel.Roles?.Where(r =>
staffRoles.Contains(r, StringComparer.OrdinalIgnoreCase)
).ToList();
string randomPwd = _pwdGenerator.Next();
IdentityResult result = await _userManager.CreateAsync(user, randomPwd);
if (!result.Succeeded)
{
return(IdentityResult.Failed(result.Errors.ToArray()));
}
await _emailSender.SendEmailAsync(user.Email, "Register at the market",
"Your employee account password: " + randomPwd);
if (availableRoles == null || !availableRoles.Any())
{
return(result);
}
IdentityResult rolesResult = await _userManager
.AddToRolesAsync(user, availableRoles);
if (rolesResult.Succeeded)
{
return(result);
}
List <IdentityError> errors = result.Errors.ToList();
errors.AddRange(rolesResult.Errors);
result = IdentityResult.Failed(errors.ToArray());
return(result);
}
public IActionResult AddNewEmployee(EmployeeCreateDTO employee)
{
var guid = service.AddNewEmployee(employee);
string location = linkGenerator.GetPathByAction("GetEmployeeByID", "Employee", new { employeeID = guid });
return(Created(location, guid));
}
public int CreateEmployee(EmployeeCreateDTO employee)
{
var emp = new Employee()
{
FirstName = employee.FirstName,
LastName = employee.LastName,
// ImageUrl = employee.ImageUrl,
Email = employee.Email,
Username = employee.Username,
Designation = employee.Designation,
EmployeePersonal = new EmployeePersonal()
{
DateOfBirth = employee.DateOfBirth,
Age = Utils.Helper.CalculateAge(employee.DateOfBirth),
Phone = employee.Phone,
IRD = employee.IRD,
City = employee.City
},
EmployeeContract = new EmployeeContract()
{
ContractHours = employee.ContractHours,
PerHourPay = employee.PerHourPay,
OvertimeRate = employee.OvertimeRate,
ContractType = employee.ContractType,
KiwiSaver = employee.KiwiSaver,
Union = employee.Union,
},
CreatedAt = DateTime.Now,
};
if (employee.ImageUrl != null && employee.ImageUrl.Length > 0)
{
var uploadFol = @"images/Employee";
var fileName = Path.GetFileNameWithoutExtension(employee.ImageUrl.FileName);
var extension = Path.GetExtension(employee.ImageUrl.FileName);
var webRootPath = _hostingenvironment.WebRootPath;
fileName = DateTime.UtcNow.ToString("yymmssfff") + fileName + extension;
var path = Path.Combine(webRootPath, uploadFol, fileName);
employee.ImageUrl.CopyTo(new FileStream(path, FileMode.Create));
emp.ImageUrl = "/" + uploadFol + "/" + fileName;
}
_context.Add(emp);
_context.SaveChanges();
var emailObj = new EmailModel()
{
toemail = emp.Email,
subject = $"Your profile has been registered",
message = $"Your profile has been created and your username is {emp.Username}.",
isHtml = false,
};
_sendemail.SendEmailHelper(emailObj);
return(emp.employeeId);
}
public async Task <IActionResult> insertEmployee(EmployeeCreateDTO employeeDTO)
{
Employee employee = _mapper.Map <Employee>(employeeDTO);
try{
await _employeeService.insertEmployee(employee);
await _userService.addUser(employee.Email, employeeDTO.Password, "Employee");
}catch (Exception ex) {
return(BadRequest(ex.Message));
}
return(Ok("Employee has been created"));
}
public async Task <ActionResult <EmployeeDTO> > CreateEmployeeForCompany(
[FromRoute] Guid companyId,
[FromBody] EmployeeCreateDTO employeeCreateDTO)
{
if (!await this.companyRepository.CompanyExistAsync(companyId))
{
return(this.NotFound());
}
var employee = this.mapper.Map <Employee>(employeeCreateDTO);
this.companyRepository.AddEmployee(companyId, employee);
await this.companyRepository.SaveAsync();
var employeeDTO = this.mapper.Map <EmployeeDTO>(employee);
return(this.CreatedAtAction(
nameof(GetEmployeeForCompany),
new { companyId = companyId, employeeId = employee.Id },
employeeDTO));
}
public IActionResult AddEmployee([FromBody] EmployeeCreateDTO employee)
{
if (ModelState.IsValid)
{
var employeeEntity = _mapper.Map <Employee>(employee);
bool isSaved = _employeeManager.Add(employeeEntity);
if (isSaved)
{
employeeEntity.Id = employee.Id;
return(Ok(employeeEntity));
}
else
{
return(BadRequest("customer is invalid"));
}
}
else
{
return(BadRequest(ModelState));
}
}
public async Task <ActionResult <Employee> > Create([FromBody] EmployeeCreateDTO employeeCreateDTO)
{
if (employeeCreateDTO == null)
{
return(BadRequest(ModelState));
}
if (await _employeeRepository.EmployeeExists(employeeCreateDTO.EmployeeNumber))
{
ModelState.AddModelError("", "Employee already exists!");
return(StatusCode(404, ModelState));
}
var employee = _mapper.Map <Employee>(employeeCreateDTO);
if (!await _employeeRepository.CreateAsync(employee))
{
ModelState.AddModelError("", "Error encountered when saving to database, try again. If problem persists contact your administrator");
return(StatusCode(500, ModelState));
}
;
return(CreatedAtAction(nameof(Employee), new { Id = employee.EmployeeNumber }, employee));
}
public IActionResult AddEmployee(EmployeeCreateDTO employee)
{
return(Ok(_user.CreateEmployee(employee)));
}
public async Task <IdentityResult> EditAsync(EmployeeCreateDTO editModel)
{
var notFound = new IdentityError
{
Code = string.Empty,
Description = "No employee found."
};
if (editModel == null)
{
return(IdentityResult.Failed(notFound));
}
ApplicationUser user = await _userManager.FindByIdAsync(editModel.Id);
if (user == null || user.Id != editModel.Id)
{
return(IdentityResult.Failed(notFound));
}
user.Id = editModel.Id;
user.UserName = editModel.Email;
user.Email = editModel.Email;
user.FirstName = editModel.FirstName;
user.MiddleName = editModel.MiddleName;
user.LastName = editModel.LastName;
IEnumerable <string> staffRoles = await StaffRoles();
List <string> availableRoles = editModel.Roles?.Where(r =>
staffRoles.Contains(r, StringComparer.OrdinalIgnoreCase)
).ToList();
List <IdentityError> errors = new List <IdentityError>();
IdentityResult updateResult = await _userManager.UpdateAsync(user);
if (!updateResult.Succeeded)
{
return(IdentityResult.Failed(updateResult.Errors.ToArray()));
}
IdentityResult resetPwdResult = await ResetPasswordWithSendOnEmail(user);
if (!resetPwdResult.Succeeded)
{
errors.AddRange(resetPwdResult.Errors);
}
IList <string> currentUserRoles = await _userManager.GetRolesAsync(user);
IdentityResult rolesRemoveResult = await _userManager
.RemoveFromRolesAsync(user, currentUserRoles);
if (!rolesRemoveResult.Succeeded)
{
errors.AddRange(rolesRemoveResult.Errors);
}
else if (availableRoles != null && availableRoles.Any())
{
IdentityResult rolesAddResult = await _userManager
.AddToRolesAsync(user, availableRoles);
if (!rolesAddResult.Succeeded)
{
errors.AddRange(rolesAddResult.Errors);
}
}
return(errors.Any()
? IdentityResult.Failed(errors.ToArray())
: updateResult);
}
public Guid AddNewEmployee(EmployeeCreateDTO employee)
{
return(repository.AddNewEmployee(mapper.Map <Employee>(employee)));
}
