public async Task <List <PersonModel> > GetPersonByModel(PersonFilterModel model)
{
var personDTO = mapper.Map <PersonFilterModel, PersonFilter>(model);
var persons = await Task.FromResult(unitOfWork.PersonRepository.GetPersonByModel(personDTO).Skip(personDTO.numberOfObjectsPerPage *personDTO.pageNumber).Take(personDTO.numberOfObjectsPerPage));
return(mapper.Map <List <Person>, List <PersonModel> >(persons.ToList()));
}
private IQueryable <Person> GetFilterdedPersons(PersonFilterModel personsFilter)
{
var persons = context.Persons
.Include(x => x.City)
.Include(x => x.Phones)
.Include(x => x.RelatedPersons)
.ThenInclude(x => x.RelatedPerson)
.ThenInclude(x => x.Phones)
.GetFilterdedPersons(personsFilter);
return(persons);
}
public IActionResult Get([FromQuery] PersonFilterModel personFilter, PageRequestModel paging)
{
var persons = uow.PersonRepository.GetAll(personFilter, paging);
var personRes = mapper.Map <List <PersonResponseModel> >(persons);
var metadata = new
{
persons.TotalCount,
persons.PageSize,
persons.CurrentPage,
persons.HasNext,
persons.HasPrevious
};
Response.Headers.Add("X-Pagination", JsonConvert.SerializeObject(metadata));
return(Ok(personRes));
}
public async Task <IActionResult> GetPersonByModel(PersonFilterModel filter)
{
return(Ok(await personManager.GetPersonByModel(filter)));
}
public static IQueryable <Person> GetFilterdedPersons(this IQueryable <Person> persons, PersonFilterModel personsFilter)
{
if (personsFilter == null)
{
return(persons);
}
if (!string.IsNullOrEmpty(personsFilter.FirstName))
{
persons = persons.Where(x => x.FirstName.Contains(personsFilter.FirstName));
}
if (!string.IsNullOrEmpty(personsFilter.LastName))
{
persons = persons.Where(x => x.LastName.Contains(personsFilter.LastName));
}
if (!string.IsNullOrEmpty(personsFilter.PrivateNumber))
{
persons = persons.Where(x => x.PrivateNumber.Contains(personsFilter.PrivateNumber));
}
if (personsFilter.BirthDate.HasValue)
{
persons = persons.Where(x => x.BirthDate.Date == personsFilter.BirthDate.Value.Date);
}
if (personsFilter.CityId > 0)
{
persons = persons.Where(x => x.CityId == personsFilter.CityId);
}
if (!string.IsNullOrEmpty(personsFilter.City))
{
persons = persons
.Where(x => x.City.CityName.Contains(personsFilter.City));
}
if (personsFilter.Gender != null)
{
persons = persons
.Where(x => x.Gender == personsFilter.Gender);
}
if (personsFilter.PhoneType != null)
{
persons = persons
.Where(x => x.Phones.Any(x => x.PhoneType == personsFilter.PhoneType));
}
if (!string.IsNullOrEmpty(personsFilter.Number))
{
persons = persons
.Where(x => x.Phones.Any(x => x.Number.Contains(personsFilter.Number)));
}
if (!string.IsNullOrEmpty(personsFilter.RelatedPersonFirstName))
{
persons = persons
.Where(r => r.RelatedPersons.Any(x => x.RelatedPerson.FirstName.Contains(personsFilter.RelatedPersonFirstName)));
}
if (!string.IsNullOrEmpty(personsFilter.RelatedPersonLastName))
{
persons = persons
.Where(r => r.RelatedPersons.Any(x => x.RelatedPerson.LastName.Contains(personsFilter.RelatedPersonLastName)));
}
if (!string.IsNullOrEmpty(personsFilter.RelatedPersonPrivateNumber))
{
persons = persons
.Where(r => r.RelatedPersons.Any(x => x.RelatedPerson.PrivateNumber.Contains(personsFilter.RelatedPersonPrivateNumber)));
}
return(persons);
}
/// <summary>
/// პიროვნების ფილტრი
/// </summary>
/// <param></param>
/// <returns></returns>
public GenericResult <Page <PersonModel> > GetFilteredPerosns(int pageIndex, int pageSize, PersonFilterModel personFilsterModel)
{
var dALPersonFilsterModel = mapper.Map <PersonFilterModel, DALPersonFilterModel>(personFilsterModel);
var result = personRepository.GetFilteredPerosns(dALPersonFilsterModel);
var page = new Pager <Persons, PersonModel>(result, pageIndex, pageSize, mapper);
return(new GenericResult <Page <PersonModel> >(Result.SuccessInstance(), page.GetPage()));
}
public PagedList <Person> GetAll(PersonFilterModel personsFilter, PageRequestModel paging)
{
return(PagedList <Person> .ToPagedList(GetFilterdedPersons(personsFilter), paging.PageNumber, paging.PageSize));
}
public GenericResult <Page <PersonModel> > GetFilteredPerosns(int pageIndex, PersonFilterModel personFilsterModel, [FromQuery] int pageSize = 10)
{
return(personBLL.GetFilteredPerosns(pageIndex, pageSize, personFilsterModel));
}
public async Task <PaginatedModel <PersonDTO> > GetAllPersons(int pageNumber, int pageSize, PersonFilterModel personFilter = null)
{
PaginatedPlainModel <Person> persons = null;
if (personFilter != null)
{
var filter = PersonFilterDtoToPerson.Instance.Map(personFilter);
persons = await unitOfWork.PersonRepository.GetAll(pageNumber, pageSize, filter);
}
else
{
persons = await unitOfWork.PersonRepository.GetAll(pageNumber, pageSize);
}
//TODo smt better here
return(new PaginatedModel <PersonDTO>(persons.Select(p => PersonEntityToDtoMapper.Instance.Map(p)), persons.PageNumber, persons.PageSize, persons.TotalCount, persons.TotalPages));
}
