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