public async Task <IEnumerable <Emloyee> > GetEmployeesAsync(Guid companyid, EmployeeParameters parameters)
{
if (companyid == null)
{
throw new ArgumentNullException(nameof(companyid));
}
//if (string.IsNullOrWhiteSpace(parameters.Gender) && string.IsNullOrWhiteSpace(parameters.Q))
//{
// return await _context.Employees.Where(x => x.CompanyId == companyid).OrderBy(x => x.EmployeeNo)
//.ToListAsync();
//}
var items = _context.Employees.Where(x => x.CompanyId == companyid);
if (!string.IsNullOrWhiteSpace(parameters.Gender))
{
var gender = Enum.Parse <Gender>(parameters.Gender.Trim());
items = items.Where(x => x.Gender == gender);
}
if (!string.IsNullOrWhiteSpace(parameters.Q))
{
parameters.Q = parameters.Q.Trim();
items = items.Where(x => x.EmployeeNo.Contains(parameters.Q) || x.FirstName.Contains(parameters.Q) || x.LastName.Contains(parameters.Q));
}
//过滤搜索结束开始排序 自定义映射关系
var mappingDictionay = _propertyMappingService.GetPropertyMapping <EmployeeDto, Emloyee>();
items = items.ApplySort(parameters.OrderBy, mappingDictionay);
return(await items.ToListAsync());
}
public async Task <IActionResult> GetEmployeesForCompany(Guid companyId, [FromQuery] EmployeeParameters employeeParameters)
{
if (!employeeParameters.ValidAgeRange)
{
return(BadRequest("Max age can't be less than min age."));
}
var company = await _repository.Company.GetCompanyAsync(companyId, false);
if (company == null)
{
_logger.LogInfo($"Company with id: {companyId} doesn't exist in the database.");
return(NotFound());
}
var employeesFromDb = await _repository.Employee.GetEmployeesAsync(companyId,
employeeParameters, trackChanges : false);
Response.Headers.Add("X-Pagination", JsonConvert.SerializeObject(employeesFromDb.MetaData));
var employeesDto = _mapper.Map <IEnumerable <EmployeeDto> >(employeesFromDb);
var links = _employeeLinks.TryGenerateLinks(employeesDto, employeeParameters.Fields, companyId, HttpContext);
return(links.HasLinks ? Ok(links.LinkedEntities) : Ok(links.ShapedEntities));
}
public async Task <IActionResult> GetEmployeesForCompany(Guid companyId, [FromQuery] EmployeeParameters employeeParameters)
{
if (!employeeParameters.ValidAgeRange)
{
return(BadRequest("Max age can't be less than min age."));
}
var company = await _repository.Company.GetCompanyAsync(companyId, trackChanges : false);
if (company == null)
{
_logger.LogInfo($"Company with id: {companyId} doesn't exist in the database.");
return(NotFound());
}
var employeesFromDb = await _repository.Employee.GetEmployeesAsync(companyId, employeeParameters, trackChanges : false);
Response.Headers.Add("X-Pagination", JsonConvert.SerializeObject(employeesFromDb.MetaData));
//var employeeDto = _mapper.Map<IEnumerable<EmployeeDto>>(employeesFromDb);
var employeesDto = employeesFromDb.Select(e => new EmployeeDto
{
Id = e.Id,
Name = e.Name,
Age = e.Age,
Position = e.Position
}).ToList();
//return Ok(employeesDto);
return(Ok(_dataShaper.ShapeData(employeesDto, employeeParameters.Fields)));
}
[HttpGet("all")]//Мы используем [FromQuery] чтобы указать, что мы будем использовать параметры запроса, чтобы определить, какую страницу и сколько сотрудников мы запрашиваем.
public IActionResult GetAllEmployees([FromQuery] EmployeeParameters employeeParameters)
{
if (!employeeParameters.ValidAgeRange)
{
return(BadRequest("Max age can't be less than min age."));
}
try
{
var emloeers = _wrapper.Employee.FindAllEmployeere(trackChanges: false, employeeParameters);
Response.Headers.Add("X-Pagination", JsonConvert.SerializeObject(emloeers.MetaData));
var count = emloeers.Count();
if (count <= 0)
{
_logger.LogError("Сотрудников в базе нет");
return(BadRequest("Сотрудников в базе нет"));
}
_logger.LogInfo($"Сотрудники были успешно получены. Количество: {count}");
_mapper.Map <IEnumerable <EmployeeDto> >(emloeers);
return(Ok(emloeers));
}
catch (Exception ex)
{
_logger.LogError($"При попытке получения Компаний произошла ошибка. Подробности " +
$"{ex.Message},\n {ex.Source}, \n {ex.HelpLink}");
return(BadRequest($"При попытке получения Компаний произошла ошибка. Подробности " +
$"{ex.Message},\n {ex.Source}, \n {ex.HelpLink}"));
}
}
public async Task EmployeesController_GetEmployeesForCompany_ShouldNot_ReturnEmployeesWhenAgeRangeIsInvalid()
{
var companyId = Guid.NewGuid();
var employeeRequest = new EmployeeParameters
{
MaxAge = 27,
MinAge = 29
};
EmployeesController employeesController = new EmployeesController(
_mockedRepositoryManager.Object,
_mockedLogger.Object,
_mapper,
null,
null
);
var badRequestObjectResult = await employeesController.GetEmployeesForCompanyAsync(companyId, employeeRequest) as BadRequestObjectResult;
using var scope = new AssertionScope();
badRequestObjectResult
.StatusCode
.Should()
.Be((int)HttpStatusCode.BadRequest);
var logMessage = "Max age can't be less than min age.";
badRequestObjectResult
.Value
.Should()
.BeEquivalentTo(logMessage);
}
public async Task <PagedList <Employee> > GetEmployeesAsync(Guid companyId, EmployeeParameters employeeParameters, bool trackChanges)
{
var employees = await FindByCondition(x => x.CompanyId.Equals(companyId), trackChanges).FilterEmployees(employeeParameters.MinAge, employeeParameters.MaxAge)
.Search(employeeParameters.SearchTerm).Sort(employeeParameters.OrderBy).ToListAsync();
return(PagedList <Employee> .ToPagedList(employees, employeeParameters.PageNumber, employeeParameters.PageSize));
}
/// <summary>
/// To get list according to parameters like page,filters,search etc.
/// </summary>
/// <param name="parameters"></param>
/// <returns></returns>
public EmployeePagedModel GetActiveListByPagination(EmployeeParameters parameters)
{
_Logger.Info("DataAccessOperations.GetActiveListByPagination() called.");
EmployeePagedModel EmployeeList = new EmployeePagedModel();
try
{
using (MySqlConnection Connection = new MySqlConnection(_ConnectionString))
{
Connection.Open();
MySqlCommand Command = new MySqlCommand("GetActiveEmployeesWithFilters", Connection);
Command.CommandType = CommandType.StoredProcedure;
Command.Parameters.AddWithValue("@orgId", parameters.OrganisationId ?? string.Empty);
Command.Parameters.AddWithValue("@searchstring", parameters.SearchString ?? string.Empty);
Command.Parameters.AddWithValue("@sortorder", parameters.SortOrder);
Command.Parameters.AddWithValue("@departmentfilter", parameters.DepartmentFilter);
Command.Parameters.AddWithValue("@genderfilter", parameters.GenderFilter);
Command.Parameters.AddWithValue("@lowerlimit", parameters.LowerLimit);
Command.Parameters.AddWithValue("@upperlimit", parameters.UpperLimit);
MySqlDataReader DataReader = Command.ExecuteReader();
EmployeeList.Employees = new List <Employee>();
CreateEmployeeListBasedOnFilters(EmployeeList, DataReader);
}
}
catch (Exception ex)
{
_Logger.Fatal(ex.ToString());
throw ex;
}
return(EmployeeList);
}
public async Task <IActionResult> GetEmployeesForCompany(
Guid companyId,
[FromQuery] EmployeeParameters employeeParameters)
{
if (!employeeParameters.ValidAgeRange)
{
return(BadRequest("Max age cannot be less than the min age."));
}
var company = await _repo.Company.GetCompanyAsync(companyId, trackChanges : false);
if (company == null)
{
_logger.LogInfo($"Company with id {companyId} does not exist in the database");
return(NotFound());
}
else
{
var employeesFromDb = await _repo.Employee.GetEmployeesAsync(companyId, employeeParameters, trackChanges : false);
Response.Headers.Add("X-Pagination", JsonConvert.SerializeObject(employeesFromDb.MetaData));
var employeeDto = _mapper.Map <IEnumerable <EmployeeDTO> >(employeesFromDb);
return(Ok(_dataShaper.ShapeData(employeeDto, employeeParameters.Fields)));
}
}
public async Task <PageList <Employee> > GetEmployeesAsync(Guid companyId, EmployeeParameters parameters)
{
if (companyId == Guid.Empty)
{
throw new ArgumentNullException(nameof(companyId));
}
var items = this.routineDbContext.Employees.Where(e => e.companyId == companyId);
if (!string.IsNullOrWhiteSpace(parameters.SearchQuery))
{
parameters.SearchQuery = parameters.SearchQuery.Trim();
items = items.Where(x => x.firstName.Contains(parameters.SearchQuery) || x.lastName.Contains(parameters.SearchQuery) || x.employeeNo.Contains(parameters.SearchQuery));
}
if (!string.IsNullOrWhiteSpace(parameters.Gender))
{
items = items.Where(e => e.Gender == Enum.Parse <Gender>(parameters.Gender.Trim()));
}
if (!string.IsNullOrWhiteSpace(parameters.Q))
{
parameters.Q = parameters.Q.Trim();
items = items.Where(e => e.employeeNo.Contains(parameters.Q) || e.firstName.Contains(parameters.Q) || e.lastName.Contains(parameters.Q));
}
var mappingDictionary = _propertyMappingService.GetPropertyMapping <EmployeeDto, Employee>();
items = items.ApplySort(parameters.OrderBy, mappingDictionary);
return(await PageList <Employee> .CreateAsync(items, parameters.PageNumber, parameters.PageSize));
}
public async Task <IActionResult> GetEmployeesForCompany(Guid companyId, [FromQuery] EmployeeParameters employeeParameters)
{
if (!employeeParameters.ValidAgeRange)
{
return(BadRequest("Max age should be greater than min age."));
}
var company = await _repository.Company
.GetCompanyAsync(companyId, trackChanges : false);
if (company == null)
{
_logger.LogError($"Company with ID = {companyId} not found.");
return(NotFound());
}
var employeesInDb = await _repository.Employee
.GetEmployeesAsync(companyId, employeeParameters, trackChanges : false);
Response.Headers.Add(
"X-Pagination",
JsonConvert.SerializeObject(employeesInDb.MetaData));
var employeesDto = _mapper.Map <IEnumerable <EmployeeDto> >(employeesInDb);
GenerateLinks(employeesDto, companyId);
return(Ok(_dataShaper.ShapeData(employeesDto, employeeParameters.Fields)));
}
public async Task <(IEnumerable <EmployeeDto>, Metadata)> GetManyAsync(EmployeeParameters employeeParameters)
{
var employees = await _repositoryManager.Employee
.GetAllEmployees(CurrentUserId, employeeParameters);
return(_mapper.Map <IEnumerable <EmployeeDto> >(employees), employees.Metadata);
}
public async Task <PagedList <EmployeeDomainObj> > GetEmployees(EmployeeParameters employeeParameters)
{
Func <EmployeeDomainObj, bool> filter;
var employeeStatus = employeeParameters.EmployeeStatus.ToUpper();
if (employeeStatus == "ACTIVE")
{
filter = ee => ee.IsActive == true;
}
else if (employeeStatus == "INACTIVE")
{
filter = ee => ee.IsActive == false;
}
else
{
filter = ee => ee.IsActive == true || ee.IsActive == false;
}
var employeeList = DbContext.EmployeeDomainObj.Where(filter).AsQueryable();
SearchByName(ref employeeList, employeeParameters.FirstName, employeeParameters.LastName);
var pagedList = await PagedList <EmployeeDomainObj> .ToPagedList(
employeeList
.OrderBy(ee => ee.LastName)
.ThenBy(ee => ee.FirstName)
.ThenBy(ee => ee.MiddleName),
employeeParameters.PageNumber,
employeeParameters.PageSize
);
return(pagedList);
}
public async Task <IActionResult> GetEmployees([FromQuery] EmployeeParameters employeeParameters)
{
var(employees, metadata) = await _employeeService.GetManyAsync(employeeParameters);
Response.Headers.Add("X-Pagination", JsonConvert.SerializeObject(metadata));
return(Ok(employees));
}
/// <summary>
/// Get All Employee
/// </summary>
/// <returns>Employee List</returns>
public IEnumerable <Employee> GetAllEmployee(EmployeeParameters employeeParameters)
{
return(_employeeRepository.GetAll()
.OrderBy(x => x.Id)
.Skip((employeeParameters.PageNumber - 1) * employeeParameters.PageSize)
.Take(employeeParameters.PageSize)
.ToList());
}
public async Task <IActionResult> GetEmployeesForCompany(Guid companyId, [FromQuery] EmployeeParameters employeeParameters)
{
var employeesFromDb = await _repository.Employee.GetEmployeesAsync(companyId, employeeParameters, trackChanges : false);
var employeesDto = _mapper.Map <IEnumerable <EmployeeDto> >(employeesFromDb);
return(Ok(employeesDto));
}
public async Task <PagedList <Employee> > GetEmployees(Guid companyId, EmployeeParameters employeeParameters, bool trackChanges)
{
var employees = await FindByCondition(e => e.CompanyId.Equals(companyId) &&
(e.Age >= employeeParameters.MinAge &&
e.Age <= employeeParameters.MaxAge), trackChanges)
.OrderBy(e => e.Name).ToListAsync();
return(PagedList <Employee> .ToPagedList(employees, employeeParameters.PageNumber, employeeParameters.PageSize));
}
public async Task <PagedList <Employee> > GetAllEmployeeAsync(EmployeeParameters employeeParameters)
{
var employees = FindAll().OrderBy(att => att.BranchId);
SearchByName(ref employees, employeeParameters.Name);
var sortedEmployees = _sortHelper.ApplySort(employees, employeeParameters.OrderBy);
return(await PagedList <Employee> .ToPageList(sortedEmployees,
employeeParameters.PageNumber, employeeParameters.PageSize));
}
public async Task ShouldGetAllEmployeeDomainObjs()
{
var employeeParams = new EmployeeParameters {
PageNumber = 1, PageSize = 10
};
var employees = await _employeeRepo.GetEmployees(employeeParams);
var count = employees.Count;
Assert.Equal(6, count);
}
/// <summary>
/// В данном методе применяется пойджинг
/// </summary>
/// <param name="trackChanges"></param>
/// <param name="employeeParameters"></param>
/// <returns></returns>
public PagedList <Employee> FindAllEmployeere(bool trackChanges, EmployeeParameters employeeParameters)
{
var employees = FindAll(trackChanges)
.FilterEmployees(employeeParameters.MinAge, employeeParameters.MaxAge)
.Search(employeeParameters.SearchTerm)
.OrderBy(x => x.Name)
// .Where(x => x.Age >= employeeParameters.MinAge && x.Age <= employeeParameters.MaxAge)
.ToList();
var employeesPage = PagedList <Employee> .ToPagedList(employees, employeeParameters.PageNumber, employeeParameters.PageSize);
return(employeesPage);
}
public async Task <IActionResult> GetEmployeesForCompany(Guid companyId, [FromQuery]
EmployeeParameters employeeParameters)
{
var company = HttpContext.Items["company"] as Company;
var employeesFromDb = await _repository.Employee.GetEmployeesAsync(company.Id, employeeParameters,
trackChanges : false);
Response.Headers.Add("X-Pagination", JsonConvert.SerializeObject(employeesFromDb.MetaData));
var employeesDto = _mapper.Map <IEnumerable <EmployeeDTO> >(employeesFromDb);
return(Ok(employeesDto));
}
public async Task <PagedList <Employee> > GetAllEmployees(Guid userId, EmployeeParameters employeeParameters)
{
var result =
await FindByCondition(x => x.User.Id.Equals(userId))
.FilterBy(employeeParameters)
.Search(employeeParameters.SearchTerm)
.Sort(employeeParameters.OrderBy)
.Include(x => x.Devices)
.Include(x => x.Licenses)
.ToListAsync();
return(PagedList <Employee> .ToPagedList(result, employeeParameters.PageNumber, employeeParameters.PageSize));
}
//GetEmployeesForCompany(Guid companyId,[FromQuery(Name = "gender")]string genderDisplay,
// string q)
GetEmployeesForCompany(Guid companyId, [FromQuery] EmployeeParameters parameters)
//[FromQuery(Name = "gender")] Query String
{
if (!await _companyRepository.CompanyExistsAsync(companyId))
{
return(NotFound());
}
//var employees = await _companyRepository.GetEmployeesAsync(companyId,genderDisplay,q);
var employees = await _companyRepository.GetEmployeesAsync(companyId, parameters);
var employeeDtos = _mapper.Map <IEnumerable <EmployeeDto> >(employees);
return(Ok(employeeDtos));
}
public async Task EmployeesController_GetEmployeesForCompany_ShouldNot_ReturnEmployeesWithPaging()
{
var companyId = Guid.NewGuid();
var trackChanges = false;
var employeeRequest = new EmployeeParameters
{
PageNumber = 1,
PageSize = 3,
};
EmployeesController employeesController = new EmployeesController(
_mockedRepositoryManager.Object,
_mockedLogger.Object,
_mapper,
null,
null
);
_mockedCompanyRepository.Setup(
companyRepo => companyRepo.GetCompanyAsync(companyId, trackChanges)
)
.Returns(
Task.FromResult <Entities.Models.Company>(
null
)
);
var notFoundObjectResult = await employeesController.GetEmployeesForCompanyAsync(companyId, employeeRequest) as NotFoundObjectResult;
using var scope = new AssertionScope();
notFoundObjectResult
.StatusCode
.Should()
.Be((int)HttpStatusCode.NotFound);
var logMessage = $"Company with id: { companyId } doesn't exist in the database.";
notFoundObjectResult
.Value
.Should()
.BeEquivalentTo(logMessage);
}
public async Task <IActionResult> GetEmployeesForCompany(Guid companyId, [FromQuery] EmployeeParameters employeeParameters)
{
if (!employeeParameters.ValidAgeRange)
{
return(BadRequest("Max age can't be less than min age."));
}
var company = await _repository.Company.GetCompanyAsync(companyId, trackChanges : false);
if (company == null)
{
_logger.LogInfo($"Company with id: {companyId} doesn't exist in the database.");
return(NotFound());
}
var employeesFromDb = await _repository.Employee.GetEmployeesAsync(companyId, employeeParameters, trackChanges : false);
var employeesDto = _mapper.Map <IEnumerable <EmployeeDto> >(employeesFromDb);
return(Ok(employeesDto));
}
public async Task <IActionResult> GetEmployeesForCompany(Guid companyId, [FromQuery] EmployeeParameters empParams)
{
if (!empParams.ValidAgeRange)
{
return(BadRequest("Max age cannot be less than min age"));
}
var employees = await _repository.Employee.GetEmployeesForCompanyAsync(companyId, empParams, trackChanges : false);
Response.Headers.Add("X-Pagination", JsonConvert.SerializeObject(employees.Metadata));
var employeesDto = _mapper.Map <IEnumerable <EmployeeDto> >(employees);
var links = _employeeLinks.TryGenerateLinks(employeesDto, empParams.Fields, companyId, HttpContext);
return(links.HasLinks ? Ok(links.LinkedEntities) : Ok(links.ShapedEntities));
//return Ok(_dataShaper.ShapeData(employeesDto, empParams.Fields));
}
public void Item_Index_View_Contains_List_Of_Items_Model()
{
// Arrange
Mock <IItemService> mockItemService = new Mock <IItemService>();
Mock <IEmployeeService> mockEmployeeService = new Mock <IEmployeeService>();
Mock <IItemParameters> mockitemParameters = new Mock <IItemParameters>();
Mock <IEmployeeParameters> mockEmployeeParameters = new Mock <IEmployeeParameters>();
IItemParameters parameters = new ItemParameters
{
PageSize = 5,
PageNumber = 1
};
IEmployeeParameters employeeParameters = new EmployeeParameters();
int count = 3;
List <IItem> itemList = new List <IItem>
{
new Item {
ID = Guid.NewGuid(), Name = "Hammer", Description = "Green", SerialNumber = "111", EmployeeID = null
},
new Item {
ID = Guid.NewGuid(), Name = "Hammer", Description = "Black", SerialNumber = "222", EmployeeID = null
},
new Item {
ID = Guid.NewGuid(), Name = "Phone", Description = "Samsung", SerialNumber = "333", EmployeeID = null
}
};
mockItemService.Setup(m => m.GetAllPagedListAsync(parameters)).ReturnsAsync(new StaticPagedList <IItem>(itemList, parameters.PageNumber.Value, parameters.PageSize.Value, count));
ItemController controller = new ItemController(mockItemService.Object, mockEmployeeService.Object, mockitemParameters.Object, mockEmployeeParameters.Object);
Mapper.Initialize(cfg =>
{
cfg.CreateMap <IItem, ItemIndexViewModel>();
});
// Act
var actual = (StaticPagedList <IItem>)controller.Index(null, null, null, null).Result.Model;
// Assert
Assert.IsInstanceOf <StaticPagedList <IItem> >(actual);
}
/// <summary>
/// API to GET all employees based on filters and Sort Order
/// </summary>
/// <param name="parameters"></param>
/// <returns></returns>
public IHttpActionResult PostAllActiveEmployees(EmployeeParameters parameters)
{
_Logger.Info("PostAllActiveEmployees API called.");
try
{
EmployeePagedModel EmployeeList = new EmployeePagedModel();
EmployeeList = _BusinessOperations.GetActiveListByPagination(parameters);
return(Ok(EmployeeList));
}
catch (EmployeeManagementExceptions exception)
{
_Logger.Error(exception.ToString());
return(InternalServerError(exception));
}
catch (Exception ex)
{
_Logger.Fatal(ex.ToString());
return(InternalServerError(ex));
}
}
public ActionResult Index(string id, string organisationID, string sortOrder, string currentFilter, string searchString, int?page, string departmentFilter, string genderFilter)
{
try
{
if (Session["Security"] != null)
{
if (id != Session["Security"].ToString() || organisationID != Session["Organisation"].ToString())
{
return(RedirectToAction("ERROR401", "Home"));
}
}
if (Session["AdminSecurity"] != null || organisationID != Session["Organisation"].ToString())
{
return(RedirectToAction("Index", "Admin", new { id = Session["AdminSecurity"].ToString(), organisationID = Session["Organisation"].ToString() }));
}
SetFiltersForMainGrid(ref sortOrder, ref searchString, ref departmentFilter, ref genderFilter);
int pageNumber;
int lowerLimit;
EmployeePagedModel model;
SetPaginationParameters(page, out pageNumber, out lowerLimit, out model);
using (var Client = new HttpClient())
{
Client.BaseAddress = new Uri(GlobalHelpers.WebAPIURL);
Client.DefaultRequestHeaders.Add("API_KEY", ConfigurationManager.AppSettings["APIKey"].ToString());
EmployeeParameters Parameters = new EmployeeParameters(organisationID, sortOrder, searchString, departmentFilter, genderFilter, lowerLimit, 10);
var Result = Client.PostAsJsonAsync(GlobalHelpers.GetAllActiveEmployees, Parameters).Result;
if (Result.IsSuccessStatusCode)
{
ProcessEmployeeDataForMainGrid(model, Result);
_Logger.Info("Employee list loaded.");
return(View(model));
}
}
return(RedirectToAction("ERROR404", "Home"));
}
catch (Exception ex)
{
_Logger.Fatal(ex.ToString());
return(RedirectToAction("ERROR404", "Home"));
}
}
//public async Task<IEnumerable<Employee>> GetEmployeesAsync(Guid companyId, bool trackChanges) =>
//await FindByCondition(e => e.CompanyId.Equals(companyId), trackChanges)
//.OrderBy(e => e.Name)
//.ToListAsync();
public async Task <PagedList <Employee> > GetEmployeesAsync(Guid companyId,
EmployeeParameters employeeParameters,
bool trackChanges)
{
//return await FindByCondition(e => e.CompanyId.Equals(companyId), trackChanges)
// .OrderBy(e => e.Name)
// .Skip((employeeParameters.PageNumber - 1) * employeeParameters.PageSize)
// .Take(employeeParameters.PageSize)
// .ToListAsync();
var employee = await FindByCondition(e => e.CompanyId.Equals(companyId),
trackChanges)
.FilterEmployees(employeeParameters.MinAge, employeeParameters.MaxAge)
.Search(employeeParameters.SearchTerm)
.OrderBy(e => e.Name)
.Sort(employeeParameters.OrderBy)
.ToListAsync();
return(PagedList <Employee>
.ToPagedList(employee, employeeParameters.PageNumber, employeeParameters.PageSize));
}
public async Task <IActionResult> GetEmployeesForCompany(Guid companyId, [FromQuery] EmployeeParameters employeeParameters)
{
if (!employeeParameters.ValidAgeRange)
{
return(BadRequest("Max age can't be less than min age."));
}
var company = await _repositoryManager.Company.GetCompanyAsync(companyId, trackChanges : false);
if (company == null)
{
_logger.LogError($"The Company with id: {companyId} doesn't exits in the Database.");
return(NotFound());
}
var employees = await _repositoryManager.Employee.GetEmployeesAsync(companyId, employeeParameters, trackChanges : false);
Response.Headers.Add("X-Pagination", JsonConvert.SerializeObject(employees.MetaData));
var employeeDto = _mapper.Map <IEnumerable <EmployeeDto> >(employees);
return(Ok(employeeDto));
}