public Task <PagedList <Course> > GetPaginatedTeacherCourses(int number, ListQueryStringDto query) { IQueryable <Course> courses = Context.Courses .Where(cl => cl.CoordinatorId == number); return(PagedList <Course> .Create(courses, query.Page, query.Limit)); }
public Task <PagedList <Teacher> > GetAllPaginatedAsync(ListQueryStringDto p) { IQueryable <Teacher> teachers = Context.Teachers.OrderBy(s => s.Number); if (!string.IsNullOrEmpty(p.Search)) { var query = p.Search.Trim(); int numberToSearch = -1; try { numberToSearch = Int32.Parse(query); } catch (FormatException) { // we dont want to search by number then.. } teachers = teachers.Where( s => s.Email.Contains(query) || s.Name.Contains(query) || s.Number == numberToSearch ); } return(PagedList <Teacher> .Create(teachers, p.Page, p.Limit)); }
public Task <PagedList <Class> > GetAllPaginatedAsync(ListQueryStringDto p) { IQueryable <Class> classes = Context.Classes .Include(c => c.Semester) .OrderBy(s => s.Id); if (!string.IsNullOrEmpty(p.Search)) { var query = p.Search.Trim(); int yearToSearch = -1; try { yearToSearch = Int32.Parse(query); } catch (FormatException) { // we dont want to search by number then.. } classes = classes.Where( s => s.Semester.Year == yearToSearch || //TODO: maybe add string 1617V? s.Name.Contains(query) ); } return(PagedList <Class> .Create(classes, p.Page, p.Limit)); }
public SirenEntity Collection(PagedList <T> items, ListQueryStringDto query) { var entity = new SirenEntityBuilder() .WithClass(Class) .WithClass("collection"); AddCollectionProperties(entity, items, query); foreach (var item in items) { var subEntity = SubEntity(item); var embeddedEntity = subEntity as EmbeddedRepresentationBuilder; if (embeddedEntity != null) { embeddedEntity.WithRel("item"); entity.WithSubEntity(embeddedEntity); } } AddCollectionActions(entity); AddNavigationLinks(entity, items.TotalPages, query); AddCollectionLinks(entity); return(entity.Build()); }
public Task <PagedList <Group> > GetClassGroups(int id, ListQueryStringDto p) { IQueryable <Group> classGroups = Context.Groups .Where(g => g.ClassId == id); return(PagedList <Group> .Create(classGroups, p.Page, p.Limit)); }
public async Task <IActionResult> List([FromQuery] ListQueryStringDto query) { var students = await _repo.GetAllPaginatedAsync(query); var result = _studentsRep.Collection(students, query); return(Ok(result)); }
public async Task <IActionResult> GetAll([FromQuery] ListQueryStringDto query) { var teachers = await _repo.GetAllPaginatedAsync(query); var result = _teachersRep.Collection(teachers, query); return(Ok(result)); }
public Task <PagedList <Teacher> > GetClassTeachers(int id, ListQueryStringDto query) { IQueryable <Teacher> teachers = Context.Teachers .Where(teacher => teacher.Classes .Where(ct => ct.ClassId == id) .FirstOrDefault() != default(ClassTeacher) ); return(PagedList <Teacher> .Create(teachers, query.Page, query.Limit)); }
public Task <PagedList <Student> > GetClassStudents(int id, ListQueryStringDto query) { IQueryable <Student> students = Context.Students .Where(student => student.Classes .Where(cs => cs.ClassId == id) .FirstOrDefault() != default(ClassStudent) ); return(PagedList <Student> .Create(students, query.Page, query.Limit)); }
public Task <PagedList <Class> > GetStudentClasses(int number, ListQueryStringDto query) { IQueryable <Class> classes = Context.Classes .Where(cl => cl.Participants .Where(cs => cs.StudentId == number) .FirstOrDefault() != default(ClassStudent) ).Include(cl => cl.Semester); return(PagedList <Class> .Create(classes, query.Page, query.Limit)); }
public Task <PagedList <Class> > GetCourseClassesAsync(int id, ListQueryStringDto query) { IQueryable <Class> classes = Context.Classes .Where(c => c.CourseId == id) .Include(c => c.Course) .Include(c => c.Semester) .Include(c => c.Groups) .OrderBy(c => c.Semester); return(PagedList <Class> .Create(classes, query.Page, query.Limit)); }
public Task <PagedList <Class> > GetPaginatedTeacherClassesAsync( int number, ListQueryStringDto query) { IQueryable <Class> classes = Context.Classes .Where(cl => cl.Teachers .Where(ct => ct.TeacherId == number) .FirstOrDefault() != default(ClassTeacher) ).Include(cl => cl.Semester); return(PagedList <Class> .Create(classes, query.Page, query.Limit)); }
private string GenerateLinkToListPage( string listRoute, ListQueryStringDto query, int pageOffset = 0) { return(Url.AbsoluteRouteUrl(listRoute, new { page = query.Page + pageOffset, limit = query.Limit, search = query.Search })); }
public Task <PagedList <Course> > GetAllPaginatedAsync(ListQueryStringDto p) { IQueryable <Course> courses = Context.Courses .Include(c => c.Coordinator); //TODO: search by number if (!string.IsNullOrEmpty(p.Search)) { var query = p.Search.Trim(); courses = courses.Where(c => c.Name.Contains(query)); } return(PagedList <Course> .Create(courses, p.Page, p.Limit)); }
public async Task <IActionResult> ClassStudents(int Id, [FromQuery] ListQueryStringDto query) { Class c = await _classesRepo.GetByIdAsync(Id); if (c == null) { return(NotFound(new ProblemJson { Type = "/class-not-found", Status = 404, Title = "Class Not Found", Detail = "The class with the id " + Id + " does not exist or it wasn't found." })); } PagedList <Student> students = await _classesRepo.GetClassStudents(Id, query); return(Ok(_studentsRep.WeakCollection(Id, students, query))); }
public async Task <IActionResult> GetCourseClasses(int Id, [FromQuery] ListQueryStringDto query) { Course course = await _repo.GetByIdAsync(Id); if (course == null) { return(NotFound(new ProblemJson { Type = "/course-not-found", Status = 404, Title = "Course Not Found", Detail = "The course with the id " + Id + " does not exist or it wasn't found." })); } PagedList <Class> classes = await _repo.GetCourseClassesAsync(Id, query); return(Ok(_classesRep.WeakCollection(Id, classes, query))); }
/* |----------------------------------------------------------------------- | Helpers |----------------------------------------------------------------------- */ protected SirenEntityBuilder AddCollectionProperties( SirenEntityBuilder entity, PagedList <T> items, ListQueryStringDto query) { entity .WithProperty("totalCount", items.TotalCount) .WithProperty("totalPages", items.TotalPages) .WithProperty("currentPage", items.CurrentPage) .WithProperty("pageSize", items.PageSize); if (!string.IsNullOrEmpty(query.Search)) { entity.WithProperty("search", query.Search); } return(entity); }
public async Task <IActionResult> Classes(int Number, [FromQuery] ListQueryStringDto query) { Student student = await _repo.GetByNumberAsync(Number); if (student == null) { return(NotFound(new ProblemJson { Type = "/student-not-found", Status = 404, Title = "Student Not Found", Detail = "The student with the number " + Number + " does not exist or it wasn't found." })); } PagedList <Class> classes = await _repo.GetStudentClasses(Number, query); return(Ok(_classesRep.WeakCollection(Number, classes, query))); }
public async Task <IActionResult> TeacherCourses( int Number, [FromQuery] ListQueryStringDto query) { Teacher teacher = await _repo.GetByNumberAsync(Number); if (teacher == null) { return(NotFound(new ProblemJson { Type = "/teacher-not-found", Status = 404, Title = "Teacher Not Found", Detail = "The teacher with the number " + Number + " does not exist or it wasn't found." })); } PagedList <Course> courses = await _repo.GetPaginatedTeacherCourses(Number, query); return(Ok(_coursesRep.WeakCollection(Number, courses, query))); }
protected SirenEntityBuilder AddNavigationLinks( SirenEntityBuilder entity, int totalPages, ListQueryStringDto query) { if (query.Page < totalPages) { entity .WithLink(new LinkBuilder() .WithRel("next") .WithHref(GenerateLinkToListPage(RouteList, query, 1))); } if (query.Page > 1) { entity .WithLink(new LinkBuilder() .WithRel("prev") .WithHref(GenerateLinkToListPage(RouteList, query, -1))); } return(entity); }
public async Task <IActionResult> GetAll([FromQuery] ListQueryStringDto query) { PagedList <Course> courses = await _repo.GetAllPaginatedAsync(query); return(Ok(_coursesRep.Collection(courses, query))); }
public SirenEntity WeakCollection(int Id, PagedList <Course> items, ListQueryStringDto query) { Identifier = Id; return(this.Collection(items, query)); }