public async Task CreateAsync(RegisterEmployeeViewModel viewModel)
{
var employee = new EmployeeModel
{
EmployeeId = viewModel.EmployeeId,
GlobalId = viewModel.GlobalId,
CardId = viewModel.CardId,
EmployeeType = viewModel.EmployeeType,
Title = viewModel.Title,
TitleThai = viewModel.TitleThai,
FirstName = viewModel.FirstName,
LastName = viewModel.LastName,
FirstNameThai = viewModel.FirstNameThai,
LastNameThai = viewModel.LastNameThai,
Gender = viewModel.Gender,
Height = viewModel.Height,
Hand = viewModel.Hand,
BirthDate = viewModel.BirthDate,
HireType = viewModel.HireType,
HireDate = viewModel.HireDate,
AvailableFlag = true,
ChangedDate = DateTime.Now,
};
await _employeeService.AddAsync(employee);
}
public async Task <ActionResult> CreateAsync([FromBody] EmployeeCreateModel employee)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
EmployeeCreateServiceModel employeeToCreate = new EmployeeCreateServiceModel
{
FirstName = employee.FirstName,
LastName = employee.LastName,
Salary = employee.Salary,
ExperienceLevel = employee.ExperienceLevel,
StartingDate = employee.StartingDate,
VacationDays = employee.VacationDays,
Image = employee.Image,
OfficeIds = employee.OfficeIds
};
//TODO: Fix the image problem.
//var file = Request.Form.Files[0];
int createdEmployeeId = await employeesService
.AddAsync(employeeToCreate);
return(CreatedAtAction(nameof(GetByIdAsync), new { id = createdEmployeeId }));
}
public async Task <IActionResult> AddAsync([FromBody] CreateEmployeeModel model)
{
try
{
var employee = Mapper.Map <Employee>(model);
Employee createdEmployee = await _employeeService.AddAsync(employee);
var employeeModel = Mapper.Map <EmployeeModel>(createdEmployee);
return(Ok(employeeModel));
}
catch (MerchantNotFoundException ex)
{
_log.WarningWithDetails(ex.Message, new { ex.MerchantId });
return(NotFound(ErrorResponse.Create(ex.Message)));
}
catch (EmployeeExistException ex)
{
_log.WarningWithDetails(ex.Message, model.Sanitize());
return(BadRequest(ErrorResponse.Create(ex.Message)));
}
}
public async Task <IActionResult> Create(Employee employee)
{
if (ModelState.IsValid)
{
await _service.AddAsync(employee);
return(RedirectToAction(nameof(Index)));
}
return(View(employee));
}
public async Task <IActionResult> Add(Employee model)
{
if (ModelState.IsValid)
{
await _employeeService.AddAsync(model);
return(RedirectToAction("Index", "Employee"));
}
return(View(model));
}
public async Task <IActionResult> Create([Bind("EmployeeId,FirstName,LastName,Position,Department,DOB,Salary")] Employee employee)
{
if (ModelState.IsValid)
{
await _employeeService.AddAsync(employee);
return(RedirectToAction(nameof(Index)));
}
return(View(employee));
}
public async Task <IActionResult> AddAsync(Contracts.Employee employee)
{
if (!ModelState.IsValid)
{
return(View("Add"));
}
await _employeeService.AddAsync(employee);
return(RedirectToAction("Index"));
}
public async Task <ActionResult <EmployeeResponse> > Post(EmployeeRequest employeeRequest)
{
if (!EmployeeExists(employeeRequest.SerialNumber))
{
var employee = ConvertEmployeeRequestToEmployee(employeeRequest);
await _service.AddAsync(employee);
return(CreatedAtAction(nameof(GetItem), new { id = employee.Id }, ConvertEmployeeToEmployeeResponse(employee)));
}
return(new ConflictObjectResult(new { message = $"Already exists a job with this serial number {employeeRequest.SerialNumber}" }));
}
public virtual async Task <ActionResult> Create(CreateEmployeeViewModel employee)
{
if (ModelState.IsValid)
{
var model = _mapper.Map <CreateEmployeeViewModel, Employee>(employee);
await _empService.AddAsync(model);
return(RedirectToAction("Index"));
}
return(View(employee));
}
public async Task <string> Handle(CreateEmployeeCommand request, CancellationToken cancellationToken)
{
var employee = mapper.Map <User>(request);
var EmployeeId = await employeeService.AddAsync(employee);
if (EmployeeId != null)
{
logger.LogInformation($"New user Created (Id = {EmployeeId}.)");
}
return(EmployeeId);
}
public async Task <IActionResult> CreateEmployee(EmployeeEditDto employeeEditDto)
{
employeeEditDto.Active = true;
var employee = _mapper.Map <Employee>(employeeEditDto);
var addedEmployee = await _service.AddAsync(employee);
if (addedEmployee != null)
{
return(StatusCode(201));
}
else
{
return(BadRequest());
}
}
public async Task <ActionResult> CreateEmployee(Employee employee)
{
if (!ModelState.IsValid)
{
ViewBag.employee = "Not Valid";
}
try
{
await _employeeService.AddAsync(employee);
}
catch (ArgumentNullException e)
{
Console.WriteLine(e);
throw;
}
return(View());
}
public async Task <IActionResult> Post([FromBody] EmployeeDto value)
{
if (value == null)
{
return(InvalidRequestBodyJson(nameof(EmployeeDto)));
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var newEmployee = Mapper.Map <Employee>(value);
newEmployee.TenantId = _tenantIdProvider.GetTenantId();
await _employeeService.AddAsync(newEmployee);
return(Created(nameof(GetEmployee), new CreatedWithGuidDto {
Id = newEmployee.Id
}));
}
public async Task <IActionResult> Register(RegisterEmployeeViewModel viewModel)
{
if (!ModelState.IsValid)
{
return(View(viewModel));
}
var employeeExist = await _employeeService.ExistsAsync(viewModel.EmployeeId);
if (employeeExist)
{
ModelState.AddModelError("Error", "Employee ID already exists.");
return(View(viewModel));
}
var employee = new EmployeeModel
{
EmployeeId = viewModel.EmployeeId,
GlobalId = viewModel.GlobalId,
CardId = viewModel.CardId,
EmployeeType = viewModel.EmployeeType,
Title = viewModel.Title,
TitleThai = viewModel.TitleThai,
FirstName = viewModel.FirstName,
LastName = viewModel.LastName,
FirstNameThai = viewModel.FirstNameThai,
LastNameThai = viewModel.LastNameThai,
Gender = viewModel.Gender,
Height = viewModel.Height,
Hand = viewModel.Hand,
BirthDate = viewModel.BirthDate,
HireType = viewModel.HireType,
HireDate = viewModel.HireDate,
AvailableFlag = true,
ChangedDate = DateTime.Now,
};
await _employeeService.AddAsync(employee);
return(RedirectToAction(nameof(EmployeeList)));
}
public async Task<CommandHandlingResult> Handle(RegisterEmployeeCommand command, IEventPublisher publisher)
{
Employee employee;
try
{
employee = await _employeeService.AddAsync(Mapper.Map<Employee>(command));
}
catch (Exception e)
{
if (e is MerchantNotFoundException merchantEx)
_log.WarningWithDetails(merchantEx.Message, new {merchantEx.MerchantId});
if (e is EmployeeExistException employeeEx)
_log.WarningWithDetails(employeeEx.Message, new { command.Email });
publisher.PublishEvent(new EmployeeRegistrationFailedEvent
{
Email = command.Email,
Error = e.Message
});
_chaosKitty.Meow("Issue with RabbitMq publishing EmployeeRegistrationFailedEvent");
return CommandHandlingResult.Ok();
}
publisher.PublishEvent(new EmployeeRegisteredEvent
{
Id = employee.Id,
Email = employee.Email,
MerchantId = employee.MerchantId,
Password = command.Password
});
_chaosKitty.Meow("Issue with RabbitMq publishing EmployeeRegisteredEvent");
return CommandHandlingResult.Ok();
}
public async Task <IActionResult> PostAsync([FromBody] Employee employee)
{
var employeeCreated = await _employeeService.AddAsync(employee);
return(Ok(employeeCreated));
}
public async Task PostAsync([FromBody] Employee model)
{
await _employeeService.AddAsync(model);
}
public async Task <IResult> AddAsync(EmployeeDto dto)
{
var result = await _service.AddAsync(dto);
return(result);
}
