public async Task <IEnumerable <UniversityModel> > GetAllByFilterAsync(UniversityFilter filter)
{
var daoFilter = _mapper.Map <UniversityFilter, UniversityFilterInSql>(filter);
var daos = await _universityRepo.GetAllBySql(daoFilter);
return(_mapper.Map <List <University>, IEnumerable <UniversityModel> >(daos));
}
public async Task <int> Count(UniversityFilter universityFilter)
{
IQueryable <UniversityDAO> universityDAOs = context.University;
universityDAOs = DynamicFilter(universityDAOs, universityFilter);
return(await universityDAOs.CountAsync());
}
public async Task <List <UniversityDTO> > List([FromBody] UniversityFilterDTO universityFilterDTO)
{
UniversityFilter universityFilter = new UniversityFilter
{
Code = new StringFilter {
StartWith = universityFilterDTO.Code
},
Name = new StringFilter {
Contain = universityFilterDTO.Name
},
Skip = universityFilterDTO.Skip,
Take = int.MaxValue,
OrderType = universityFilterDTO.OrderType,
OrderBy = UniversityOrder.Code
};
List <University> universities = await UniversityService.List(universityFilter);
List <UniversityDTO> universityDTOs = universities.Select(u => new UniversityDTO
{
Id = u.Id,
Address = u.Address,
Code = u.Code,
Name = u.Name,
Website = u.Website
}).ToList();
return(universityDTOs);
}
public async Task <List <UniversityDTO> > List([FromBody] UniversityFilterDTO universityFilterDTO)
{
UniversityFilter universityFilter = new UniversityFilter
{
Code = universityFilterDTO.Code,
Name = universityFilterDTO.Name,
Skip = universityFilterDTO.Skip,
Take = universityFilterDTO.Take,
OrderType = universityFilterDTO.OrderType,
OrderBy = universityFilterDTO.OrderBy
};
List <University> universities = await UniversityService.List(universityFilter);
List <UniversityDTO> universityDTOs = universities.Select(u => new UniversityDTO
{
Id = u.Id,
Address = u.Address,
Code = u.Code,
Name = u.Name,
Website = u.Website,
Phone = u.Phone,
Description = u.Description
}).ToList();
return(universityDTOs);
}
public async Task <ActionResult <IEnumerable <UniversityModel> > > Get([FromQuery] UniversityFilter filter)
{
_logger.LogInformation("Call end-point all universities");
if (filter.Active)
{
return(Ok(await _universityService.GetAllByFilterAsync(filter)));
}
else
{
return(Ok(await _universityService.GetAllAsync()));
}
}
public async Task <List <University> > List(UniversityFilter universityFilter)
{
if (universityFilter == null)
{
return(new List <University>());
}
IQueryable <UniversityDAO> universityDAOs = context.University;
universityDAOs = DynamicFilter(universityDAOs, universityFilter);
universityDAOs = DynamicOrder(universityDAOs, universityFilter);
var universitys = await DynamicSelect(universityDAOs);
return(universitys);
}
private async Task <bool> CodeValidate(University university)
{
//Kiểm tra Code nhập vào có tồn tại trong Db
UniversityFilter filter = new UniversityFilter
{
Code = new StringFilter {
Equal = university.Code
}
};
var count = await UOW.UniversityRepository.Count(filter);
if (count > 0)
{
university.AddError(nameof(UniversityValidator), nameof(university.Code), ErrorCode.Duplicate);
}
return(university.IsValidated);
}
public List <University> GetAll(UniversityFilter filter)
{
IEnumerable <University> result = base.GetAll();
if (filter != null)
{
if (!string.IsNullOrWhiteSpace(filter.ScientificSpecialityCode))
{
result = result.Where(s => s.ScientificSpecialities.Any(d => d.Code.ToUpperInvariant()
.Contains(filter.ScientificSpecialityCode.ToUpperInvariant())));
}
if (!string.IsNullOrWhiteSpace(filter.ScientificSpecialityName))
{
result = result.Where(s => s.ScientificSpecialities.Any(d => d.Name.ToUpperInvariant()
.Contains(filter.ScientificSpecialityName.ToUpperInvariant())));
}
}
return(result.OrderBy(s => s.Name).ToList());
}
public IHttpActionResult Get([FromUri] UniversityFilter filter)
{
try
{
List <UniversityModel> list = _repository.GetAll(filter).Select(MapEntityToModel).ToList();
var content = new EntitiesListResult <UniversityModel>
{
Data = list,
Page = -1,
PageSize = -1
};
;
content.Total = list.Count;
return(Ok(content));
}
catch (Exception e)
{
return(HandleException(e));
}
}
private IQueryable <UniversityDAO> DynamicOrder(IQueryable <UniversityDAO> query, UniversityFilter universityFilter)
{
switch (universityFilter.OrderType)
{
case OrderType.ASC:
switch (universityFilter.OrderBy)
{
case UniversityOrder.Code:
query = query.OrderBy(q => q.Code);
break;
case UniversityOrder.Name:
query = query.OrderBy(q => q.Name);
break;
default:
query = query.OrderBy(q => q.Id);
break;
}
break;
case OrderType.DESC:
switch (universityFilter.OrderBy)
{
case UniversityOrder.Code:
query = query.OrderByDescending(q => q.Code);
break;
case UniversityOrder.Name:
query = query.OrderByDescending(q => q.Name);
break;
default:
query = query.OrderByDescending(q => q.Id);
break;
}
break;
default:
query = query.OrderBy(q => q.Id);
break;
}
query = query.Skip(universityFilter.Skip).Take(universityFilter.Take);
return(query);
}
private IQueryable <UniversityDAO> DynamicFilter(IQueryable <UniversityDAO> query, UniversityFilter universityFilter)
{
if (universityFilter == null)
{
return(query.Where(q => 1 == 0));
}
if (universityFilter.Id != null)
{
query = query.Where(q => q.Id, universityFilter.Id);
}
if (universityFilter.Name != null)
{
query = query.Where(q => q.Name, universityFilter.Name);
}
if (universityFilter.Code != null)
{
query = query.Where(q => q.Code, universityFilter.Code);
}
return(query);
}
public async Task <List <University> > List(UniversityFilter universityFilter)
{
return(await UOW.UniversityRepository.List(universityFilter));
}
