public Task <PagedListResponse <ClassListResponse> > ListClassesInSchoolYear(Guid schoolYearId,
[FromQuery] PagedListQuery query, CancellationToken cancellationToken)
{
var typedQuery = query.ToTypedQuery <ClassSchoolYearListQuery>(x => x.SchoolYearId = schoolYearId);
return(mediator.Send(typedQuery, cancellationToken));
}
public Task <PagedListResponse <LessonListResponse> > ListLessons(
Guid schoolYearId,
Guid classId,
Guid subjectId,
[FromQuery] PagedListQuery query,
CancellationToken cancellationToken)
{
return(mediator.Send(query.ToTypedQuery <AdminLessonListQuery>(x =>
{
x.SchoolYearId = schoolYearId;
x.ClassId = classId;
x.SubjectId = subjectId;
}), cancellationToken));
}
public Task <PagedListResponse <GradeListByClassSchoolYearSubjectResponse> > ListGradesBySubject(
Guid schoolYearId,
Guid classId,
Guid subjectId,
[FromQuery] PagedListQuery query,
CancellationToken cancellationToken)
{
return(mediator.Send(query.ToTypedQuery <GradeListByClassSchoolYearSubjectQuery>(x =>
{
x.SchoolYearId = schoolYearId;
x.ClassId = classId;
x.SubjectId = subjectId;
}), cancellationToken));
}
public virtual async Task <PagedList <TEntity> > GetPaged(PagedListQuery query, IQueryable <TEntity> qData = null)
{
PagedList <TEntity> resultEntity = new PagedList <TEntity>();
resultEntity.PageMeta.PageNumber = query.PageNumber;
resultEntity.PageMeta.PageSize = query.PageSize;
IQueryable <TEntity> queryableData = qData != null ? qData : this.DBContext
.Set <TEntity>();
if (query.Graph is JObject)
{
IList <string> listOfProps = this.ExtractIncludes(query.Graph);
foreach (string prop in listOfProps)
{
queryableData = queryableData.Include(prop);
}
}
queryableData = this.AddFilter(queryableData, query.Filter);
queryableData = this.AddSort(queryableData, query.Sort);
// count total elements
int countPage = await queryableData.CountAsync();
resultEntity.PageMeta.TotalElements = countPage;
// count total pages
int extraCount = countPage % query.PageSize > 0 ? 1 : 0;
resultEntity.PageMeta.TotalPages = (countPage < query.PageSize) ? 1 : (countPage / query.PageSize) + extraCount;
// get elements
int countFrom = query.PageNumber == 1 ? 0 : (query.PageSize * query.PageNumber) - query.PageSize;
resultEntity.Elements = await queryableData
.Skip(countFrom)
.Take(query.PageSize)
.ToListAsync();
resultEntity.PageMeta.ElementsInPage = resultEntity.Elements.LongCount();
return(resultEntity);
}
public Task <PagedListResponse <ClassSubjectListResponse> > ListClassSubjects(Guid schoolYearId,
[FromQuery] PagedListQuery query, CancellationToken cancellationToken)
{
return(mediator.Send(query.ToTypedQuery <ClassSubjectListQuery>(x =>
{
x.SchoolYearId = schoolYearId;
}), cancellationToken));
}
public Task <PagedListResponse <LessonAbsenceListResponse> > ListLessonAbsences(Guid lessonId,
[FromQuery] PagedListQuery query, CancellationToken cancellationToken)
{
return(mediator.Send(query.ToTypedQuery <LessonAbsenceListQuery>(x =>
{
x.LessonId = lessonId;
}), cancellationToken));
}
protected async Task <PagedListQuery> GetQuery(
int pageSize,
int pageNumber,
string filter,
string sort,
string graph)
{
PagedListQuery query = new PagedListQuery();
if (pageSize != default(int))
{
query.PageSize = pageSize;
}
if (pageNumber != default(int))
{
query.PageNumber = pageNumber;
}
if (filter != default(string))
{
if (query.Filter == null)
{
query.Filter = new List <PagedListQueryFilter>();
}
if (!string.IsNullOrEmpty(filter))
{
string[] filterGroups = filter.Split(',');
foreach (string filterItem in filterGroups)
{
string[] filterSeparated = filterItem.Split('~');
if (filterSeparated.Length == 3)
{
query.Filter.Add(new PagedListQueryFilter()
{
Property = filterSeparated[0].First().ToString().ToUpper() + string.Join("", filterSeparated[0].Skip(1)),
Method = this.ParseFilterMethod(filterSeparated[1]),
Value = HttpUtility.UrlDecode(filterSeparated[2])
});
}
}
}
}
if (sort != default(string))
{
if (query.Sort == null)
{
query.Sort = new List <PagedListQuerySort>();
}
if (!string.IsNullOrEmpty(sort))
{
string[] sortGroups = sort.Split(',');
foreach (string sortItem in sortGroups)
{
string[] sortSeparated = sortItem.Split('~');
if (sortSeparated.Length == 2)
{
query.Sort.Add(new PagedListQuerySort()
{
Property = sortSeparated[0].First().ToString().ToUpper() + string.Join("", sortSeparated[0].Skip(1)),
Direction = sortSeparated[1].ToLower() == "asc" ? PagedListQuerySortDirection.Asc : PagedListQuerySortDirection.Desc
});
}
}
}
}
// prevent null
if (graph is string)
{
try
{
query.Graph = JsonConvert.DeserializeObject(graph) as JObject;
}
catch (Exception exc)
{
this.Response.StatusCode = StatusCodes.Status400BadRequest;
await this.Response.WriteAsync("JSON in 'graph' is not a valid: " + exc.Message);
return(null);
}
}
return(query);
}
public Task <PagedListResponse <UserRoleListResponse> > ListParents([FromQuery] PagedListQuery query,
CancellationToken cancellationToken)
{
return(mediator.Send(query.ToTypedQuery <ParentListQuery>(), cancellationToken));
}
public Task <PagedListResponse <UserRoleListResponse> > ListStudents(Guid id, string searchText, [FromQuery] PagedListQuery query, CancellationToken cancellationToken)
{
return(mediator.Send(query.ToTypedQuery <ClassStudentListQuery>(x =>
{
x.ClassId = id;
x.SearchText = searchText;
}), cancellationToken));
}
public async Task <PagedList <TEntity> > GetPaged(PagedListQuery query, IQueryable <TEntity> data = null)
{
List <string> gets = new List <string>();
if (query.PageNumber > 0)
{
gets.Add($"pageNumber={HttpUtility.UrlPathEncode(query.PageNumber.ToString())}");
}
if (query.PageSize > 0)
{
gets.Add($"pageSize={HttpUtility.UrlPathEncode(query.PageNumber.ToString())}");
}
if (query.Sort != null)
{
IEnumerable <string> sortRequest = query.Sort.Select((PagedListQuerySort sort) =>
{
string direction = sort.Direction == PagedListQuerySortDirection.Desc ? "desc" : "asc";
return($"{sort.Property}~{direction}");
});
gets.Add($"sort={HttpUtility.UrlPathEncode(string.Join(",", sortRequest))}");
}
if (query.Filter != null)
{
IEnumerable <string> filterRequest = query.Filter.Select((PagedListQueryFilter filter) =>
{
string method;
switch (filter.Method)
{
case PagedListQueryFilterMethod.Less:
method = "<";
break;
case PagedListQueryFilterMethod.LessOrEqual:
method = "<=";
break;
case PagedListQueryFilterMethod.GreatOrEqual:
method = ">=";
break;
case PagedListQueryFilterMethod.Great:
method = ">";
break;
case PagedListQueryFilterMethod.Like:
method = "like";
break;
case PagedListQueryFilterMethod.ILike:
method = "ilike";
break;
case PagedListQueryFilterMethod.Equal:
default:
method = "=";
break;
}
return($"{filter.Property}~{method}~{filter.Value}");
});
gets.Add($"filter={HttpUtility.UrlPathEncode(string.Join(",", filterRequest))}");
}
if (query.Graph != null)
{
gets.Add($"graph={HttpUtility.UrlPathEncode(JsonConvert.SerializeObject(query.Graph))}");
}
string url = this.BaseAdress + "/" + this.EndPoint + "/paged?" + string.Join("&", gets);
HttpResponseMessage httpResponseMessage = await this.Client.GetAsync(url);
this.CheckResponseStatus(httpResponseMessage);
string response = await httpResponseMessage.Content.ReadAsStringAsync();
return(JsonConvert.DeserializeObject <PagedList <TEntity> >(response));
}
public async Task <PagedList <TEntity> > GetPaged(PagedListQuery query)
{
return(await this.Repository.GetPaged(query));
}
public async Task <PagedList <TEntity> > GetPaged(PagedListQuery query, IQueryable <TEntity> data = null)
{
await Task.Delay(0);
throw new NotImplementedException();
}
public Task <PagedListResponse <SubjectListResponse> > GetStudentSubjectsInSchoolYear(Guid studentId,
Guid schoolYearId, [FromQuery] PagedListQuery query, CancellationToken cancellationToken)
{
return(mediator.Send(query.ToTypedQuery <StudentSubjectListQuery>(x =>
{
x.StudentId = studentId;
x.SchoolYearId = schoolYearId;
}), cancellationToken));
}
public async Task <IEnumerable <DeviceData> > GetDeviceDataSAsync(GetDeviceDataListCmd cmd, PagedListQuery plQuery)
{
using (var conn = CreateConnection())
{
conn.Open();
var sql = "SELECT * FROM device_data WHERE ";
var demo = DeviceDataFilterSql(cmd);
sql += demo.Sql;
sql += " ORDER BY update_on DESC ";
sql += plQuery.PostgresLimitPartialSql();
return(await conn.QueryAsync <DeviceData>(sql, demo.Dps).ConfigureAwait(false));
}
}
public Task <PagedListResponse <TeacherHomeworkListResponse> > GetHomeworksForLesson(Guid lessonId,
[FromQuery] PagedListQuery query, CancellationToken cancellationToken)
{
return(mediator.Send(new LessonHomeworkListQuery
{
LessonId = lessonId,
PageIndex = query.PageIndex,
PageSize = query.PageSize
}, cancellationToken));
}
public async Task <IEnumerable <UploadImages> > GetFarmInfosAsync(GetUploadImageListCmd cmd, PagedListQuery plQuery)
{
using (var conn = CreateConnection())
{
conn.Open();
var sql = "SELECT * FROM upload_images WHERE ";
var demo = UploadImageFilterSql(cmd);
sql += demo.Sql;
sql += " ORDER BY created_on DESC ";
sql += plQuery.PostgresLimitPartialSql();
return(await conn.QueryAsync <UploadImages>(sql, demo.Dps).ConfigureAwait(false));
}
}
public Task <PagedListResponse <TestAnswerListResponse> > ListAnswers(Guid testId,
[FromQuery] PagedListQuery query, CancellationToken cancellationToken)
{
return(mediator.Send(query.ToTypedQuery <TestAnswerListQuery>(query => query.TestId = testId), cancellationToken));
}
public async Task <IEnumerable <MemberInfo> > GetAllMemberInfoAsync(GetMemberListCmd cmd, PagedListQuery plQuery)
{
using (var conn = CreateConnection())
{
conn.Open();
var sql = "SELECT * FROM member_info WHERE ";
var demo = AllMemberInfoSql(cmd);
sql += demo.Sql;
sql += " ORDER BY created_on DESC ";
sql += plQuery.PostgresLimitPartialSql();
return(await conn.QueryAsync <MemberInfo>(sql, demo.Dps).ConfigureAwait(false));
}
}
