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