public async Task <IEnumerable <SearchStudentDto> > SearchAsync(SearchStudentModel searchStudentModel)
{
var query = this.Context.Students
.Include(s => s.Faculty)
.Include(s => s.University)
.Include(s => s.SpecialityByFaculty)
.ThenInclude(s => s.Speciality)
.Include(s => s.Specialization)
.Include(s => s)
.Where(s => s.UniversityId == searchStudentModel.UniversityId);
if (searchStudentModel.FacultyId.HasValue)
{
query.Where(s => s.FacultyId == searchStudentModel.FacultyId);
}
if (searchStudentModel.SpecialityByFacultyId.HasValue)
{
query.Where(s => s.SpecialityByFacultyId == searchStudentModel.SpecialityByFacultyId);
}
if (searchStudentModel.SpecializationId.HasValue)
{
query.Where(s => s.SpecializationId == searchStudentModel.SpecializationId);
}
return(await query.Select(s => new SearchStudentDto
{
Name = s.User.Firstname,
University = s.University.Name
})
.ToListAsync());
}
private Expression <Func <Student, bool> > InitilizeFilter(SearchStudentModel model)
{
var filter = PredicateBuilder.New <Student>().Start(s => true).And(f => f.StatusId == Constant.StatusId.Active);
if (!string.IsNullOrEmpty(model.Name))
{
filter = filter.And(f => f.Name == model.Name);
}
if (!string.IsNullOrEmpty(model.Email))
{
filter = filter.And(f => f.Email == model.Email);
}
if (model.Age.HasValue)
{
filter = filter.And(f => f.Age == model.Age);
}
if (model.DateOfBirth.HasValue)
{
filter = filter.And(f => f.DateOfBirth == model.DateOfBirth);
}
return(filter);
}
public List <StudentModel> Search(SearchStudentModel model)
{
using (var unit = _unitOfWork.Create())
{
var query = unit.Repository <Student>().Where(InitilizeFilter(model));
var result = query.Select(s => new StudentModel()
{
Id = s.Id,
Name = s.Name,
Email = s.Email,
Age = s.Age,
DateOfBirth = s.DateOfBirth
}).OrderBy(o => o.Name).Skip(model.Skip).Take(model.Take).ToList();
return(result);
}
}
public ActionResult SearchStudent(string sort = "Username", string order = "desc", string classID = null)
{
List <BusinessObjects.Student> students;
SearchStudentModel model = new SearchStudentModel();
students = service.GetClassStudents(classID, sort + " " + order);
var c = Mapper.Map <Class, ClassModel> (service.GetClass(classID));
c.Teacher = Mapper.Map <BusinessObjects.Teacher, PersonModel>(service.GetTeacher(c.TeacherID));
model.Class = c;
var list = Mapper.Map <List <BusinessObjects.Student>, List <PersonModel> >(students);
if (!string.IsNullOrEmpty(classID))
{
list.ForEach(c => c.ClassID = classID);
}
model.People = new SortedList <PersonModel>(list, sort, order);
return(View(model));
}
public async Task <StudentModel> SearchAsync(SearchStudentModel searchStudentModel) => new StudentModel(await _studentService.SearchAsync(searchStudentModel));
public IEnumerable <Student> QueryByName(SearchStudentModel model)
{
return(_studentLogic.QueryByName(model.FirstName, model.LastName));
}
public async Task <StudentDTO> SearchAsync(SearchStudentModel searchStudentModel)
{
IEnumerable <User> user = await _userRepository.SearchAsync(searchStudentModel);
return(new StudentDTO(user.First()));
}
