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