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));
}
