public void GetCreatedEmployeeData_PositiveTestCase() { var newEmployee = CreateEmployeeDTO.Generated(); var createEmployeeRs = client.POST( client.Request() .Path("/create") .Body(newEmployee) .Build() ); AssertThat.Response(createEmployeeRs) .StatusIs(HttpStatusCode.OK); var createEmployeeRsDTO = unmarshaller.Unmarshal <CreateEmployeeRsDTO>(createEmployeeRs); var getEmployeeRs = client.GET( client.Request() .Path($"/employee/{createEmployeeRsDTO.data.id}") .Build() ); AssertThat.Response(getEmployeeRs) .StatusIs(HttpStatusCode.OK) .And() .BodyContains("Successfully! Record has been fetched"); }
public async Task <CreateOperationResult> CreateEmployee(CreateEmployeeDTO dto) { using (var dbContext = new GrowFlowContext()) { using (var service = ComplianceService.Create(dbContext, account)) { try { var result = await service.CreateEmployeeAsync( account, dto.FirstName, dto.LastName, dto.DateOfBirth, dto.DateOfHire, dto.SocialSecurity, dto.EmployeeNum, dto.VehicleId); return(new CreateOperationResult() { Success = true, Data = result }); } catch (Exception e) { return(new CreateOperationResult() { Success = false, Exception = e.Message }); } } } }
public async Task <Result <long> > CreateEmployee(CreateEmployeeDTO dto) { var name = Name.Create(dto.Name); if (name.IsFailure) { return(Result.Failure <long>(name.Error)); } var employee = new Domain.Employee(name.Value) { Surname = dto.Surname, Patronymic = dto.Patronymic, BirthDate = dto.BirthDate, Position = dto.Position, Organization = dto.Organization, }; var contacts = this.GetContactsFromDTO(dto.Contacts); if (contacts.IsFailure) { return(Result.Failure <long>($"Can't update contacts due to errors: {contacts.Error}")); } employee.AddContacts(contacts.Value); await this.dbContext.Employees.AddAsync(employee); await this.dbContext.SaveChangesAsync(); return(Result.Success(employee.Id)); }
public async Task <ActualResult> AddEmployeeAsync(CreateEmployeeDTO dto) { var checkHashIdInDto = await CheckHashIdInDto(dto); if (!checkHashIdInDto.IsValid) { return(new ActualResult(checkHashIdInDto.ErrorsList)); } var employee = _mapperService.Mapper.Map <DAL.Entities.Employee>(dto); await _database.EmployeeRepository.Create(employee); var createEmployee = await _database.SaveAsync(); if (createEmployee.IsValid) { dto.IdEmployee = employee.Id; await _database.EducationRepository.Create(_mapperService.Mapper.Map <Education>(dto)); await _database.PositionEmployeesRepository.Create(_mapperService.Mapper.Map <PositionEmployees>(dto)); if (dto.TypeAccommodation == "privateHouse" || dto.TypeAccommodation == "fromUniversity") { await _database.PrivateHouseEmployeesRepository.Create(_mapperService.Mapper.Map <PrivateHouseEmployees>(dto)); } if (dto.TypeAccommodation == "dormitory" || dto.TypeAccommodation == "departmental") { await _database.PublicHouseEmployeesRepository.Create(_mapperService.Mapper.Map <PublicHouseEmployees>(dto)); } if (dto.Scientifick) { await _database.ScientificRepository.Create(_mapperService.Mapper.Map <Scientific>(dto)); } if (dto.SocialActivity) { await _database.SocialActivityEmployeesRepository.Create(_mapperService.Mapper.Map <SocialActivityEmployees>(dto)); } if (dto.Privileges) { await _database.PrivilegeEmployeesRepository.Create(_mapperService.Mapper.Map <PrivilegeEmployees>(dto)); } } var result = await _database.SaveAsync(); if (result.IsValid) { return(new ActualResult()); } await DeleteAsync(dto.IdEmployee); return(new ActualResult(result.ErrorsList)); }
/// <inheritdoc/> public EmployeeDTO Create(CreateEmployeeDTO createEmployeeDTO) { var employee = mapper.Map <Employee>(createEmployeeDTO); employee.User = userManager.Get(createEmployeeDTO.UserName); var entity = employeeManager.Create(employee); return(mapper.Map <EmployeeDTO>(entity)); }
public async Task CreateEmployee_NameNotSpecified_Fail() { var dto = new CreateEmployeeDTO(); await using var dbContext = GetDbContext(); var service = new EmployeesService(dbContext); var result = await service.CreateEmployee(dto); Assert.IsTrue(result.IsFailure); }
public bool AddEmployee(CreateEmployeeDTO model) { if (model != null) { var employee = _mapper.Map <tblEmployees>(model); _context.tblEmployee.Add(employee); _context.SaveChanges(); return(true); } return(false); }
public async Task CreateEmployee_NameSpecified_ContactsEmpty_Success() { var dto = new CreateEmployeeDTO { Name = "name" }; await using var dbContext = GetDbContext(); var service = new EmployeesService(dbContext); var result = await service.CreateEmployee(dto); Assert.IsTrue(result.IsSuccess); }
public IActionResult AddEmployee(CreateEmployeeDTO model) { var result = _employeeManager.AddEmployee(model); if (result) { return(Ok()); } else { return(StatusCode(500)); } }
public void CreateNewEmployee_PositiveTestCase() { var newEmployee = CreateEmployeeDTO.Generated(); var createEmployeeRs = client.POST( client.Request() .Path("/create") .Body(newEmployee) .Build() ); AssertThat.Response(createEmployeeRs) .StatusIs(HttpStatusCode.OK) .And() .BodyContains("Successfully! Record has been added."); }
public async Task <ActualResult <string> > AddEmployeeAsync(CreateEmployeeDTO dto) { try { var employee = _mapper.Map <DAL.Entities.Employee>(dto); employee.PositionEmployees = _mapper.Map <PositionEmployees>(dto); switch (dto.TypeAccommodation) { case AccommodationType.PrivateHouse: case AccommodationType.FromUniversity: employee.PrivateHouseEmployees.Add(_mapper.Map <PrivateHouseEmployees>(dto)); break; case AccommodationType.Dormitory: case AccommodationType.Departmental: employee.PublicHouseEmployees.Add(_mapper.Map <PublicHouseEmployees>(dto)); break; default: throw new ArgumentOutOfRangeException(); } if (dto.SocialActivity) { employee.SocialActivityEmployees = _mapper.Map <SocialActivityEmployees>(dto); } if (dto.Privileges) { employee.PrivilegeEmployees = _mapper.Map <PrivilegeEmployees>(dto); } await _context.Employee.AddAsync(employee); await _context.SaveChangesAsync(); var hashId = HashHelper.EncryptLong(employee.Id); return(new ActualResult <string> { Result = hashId }); } catch (Exception exception) { return(new ActualResult <string>(DescriptionExceptionHelper.GetDescriptionError(exception))); } }
public async Task <ActualResult <string> > CreateMainEmployeeAsync(CreateEmployeeDTO dto) { try { var employee = _mapper.Map <DimEmployee>(dto); await _context.DimEmployee.AddAsync(employee); await _context.SaveChangesAsync(); return(new ActualResult <string> { Result = employee.EmployeeKey.ToString() }); } catch (Exception exception) { return(new ActualResult <string>(DescriptionExceptionHelper.GetDescriptionError(exception))); } }
public async Task CreateEmployee_InvalidContacts_Fail() { var dto = new CreateEmployeeDTO { Name = "name", Contacts = new List <ContactDTO> { new ContactDTO { Type = ContactType.Email } } }; await using var dbContext = GetDbContext(); var service = new EmployeesService(dbContext); var result = await service.CreateEmployee(dto); Assert.IsTrue(result.IsFailure); }
public async Task <ActualResult> AddEmployeeAsync(CreateEmployeeDTO dto) { try { var employee = _mapperService.Mapper.Map <DAL.Entities.Employee>(dto); employee.PositionEmployees = _mapperService.Mapper.Map <PositionEmployees>(dto); if (dto.TypeAccommodation == AccommodationType.PrivateHouse || dto.TypeAccommodation == AccommodationType.FromUniversity) { employee.PrivateHouseEmployees.Add(_mapperService.Mapper.Map <PrivateHouseEmployees>(dto)); } if (dto.TypeAccommodation == AccommodationType.Dormitory || dto.TypeAccommodation == AccommodationType.Departmental) { employee.PublicHouseEmployees.Add(_mapperService.Mapper.Map <PublicHouseEmployees>(dto)); } if (dto.SocialActivity) { employee.SocialActivityEmployees = _mapperService.Mapper.Map <SocialActivityEmployees>(dto); } if (dto.Privileges) { employee.PrivilegeEmployees = _mapperService.Mapper.Map <PrivilegeEmployees>(dto); } await _context.Employee.AddAsync(employee); await _context.SaveChangesAsync(); return(new ActualResult()); } catch (Exception exception) { return(new ActualResult(DescriptionExceptionHelper.GetDescriptionError(exception))); } }
public async Task <IActionResult> CreateEmployee([FromBody] CreateEmployeeDTO employeeDTO) { if (!ModelState.IsValid) { _logger.LogError($"Invalid POST attempt in {nameof(CreateEmployee)}"); return(BadRequest(ModelState)); } try { var employee = _mapper.Map <Employee>(employeeDTO); await _unitOfWork.Employee.Insert(employee); await _unitOfWork.Save(); //Created at route returns object to slient return(CreatedAtRoute("GetEmployee", new { id = employee.Id }, employee)); } catch (Exception ex) { _logger.LogError(ex, $"Something went wrong in the {nameof(CreateEmployee)}"); return(StatusCode(500, "Internal Server Error. Please try again later.")); } }
private async Task <ActualResult> CheckHashIdInDto(CreateEmployeeDTO dto) { var checkPosition = await _hashIdUtilities.CheckDecryptWithId(dto.HashIdPosition, Enums.Services.Position); if (checkPosition != null) { dto.IdPosition = checkPosition.Result; } else { return(new ActualResult(Errors.InvalidId)); } var checkSubdivision = await _hashIdUtilities.CheckDecryptWithId(dto.HashIdSubdivision, Enums.Services.Subdivision); if (checkSubdivision != null) { dto.IdSubdivision = checkSubdivision.Result; } else { return(new ActualResult(Errors.InvalidId)); } if (dto.TypeAccommodation == "dormitory") { var checkDormitory = await _hashIdUtilities.CheckDecryptWithId(dto.HashIdDormitory, Enums.Services.Dormitory); if (checkDormitory != null) { dto.IdDormitory = checkDormitory.Result; } else { return(new ActualResult(Errors.InvalidId)); } } if (dto.TypeAccommodation == "departmental") { var checkDepartmental = await _hashIdUtilities.CheckDecryptWithId(dto.HashIdDepartmental, Enums.Services.Departmental); if (checkDepartmental != null) { dto.IdDepartmental = checkDepartmental.Result; } else { return(new ActualResult(Errors.InvalidId)); } } if (dto.SocialActivity) { var checkSocialActivity = await _hashIdUtilities.CheckDecryptWithId(dto.HashIdSocialActivity, Enums.Services.SocialActivity); if (checkSocialActivity != null) { dto.IdSocialActivity = checkSocialActivity.Result; } else { return(new ActualResult(Errors.InvalidId)); } } if (dto.Privileges) { var checkPrivileges = await _hashIdUtilities.CheckDecryptWithId(dto.HashIdPrivileges, Enums.Services.Privileges); if (checkPrivileges != null) { dto.IdPrivileges = checkPrivileges.Result; } else { return(new ActualResult(Errors.InvalidId)); } } return(new ActualResult()); }
public async Task <IActionResult> CreateEmployee([FromBody] CreateEmployeeDTO dto) { var result = await this.employeesService.CreateEmployee(dto); return(result.IsSuccess ? Ok(result.Value) : Error(result.Error)); }
public bool AddEmployee(CreateEmployeeDTO model) { return(_employeeRepository.AddEmployee(model)); }
public async Task <GetEmployeeDTO> Post([FromBody] CreateEmployeeDTO value) { return(await _service.Create(value)); }