public static async Task <PagedResult <T> > GetPagedAsync <T>(this ISieveProcessor sieveProcessor, IQueryable <T> query, SieveModel sieveModel = null) where T : class
{
var result = new PagedResult <T>();
var(pagedQuery, page, pageSize, recordCount, pageCount) = await GetPagedResultAsync(sieveProcessor, query, sieveModel);
result.CurrentPage = page;
result.PageSize = pageSize;
result.RecordCount = recordCount;
result.PageCount = pageCount;
result.Results = await pagedQuery.ToListAsync();
return(result);
}
public PagingResponse <AdResponse> Get([FromQuery] SieveModel sieveModel)
{
return(_adService.Get <AdResponse>(sieveModel));
}
public new async Task <ActionResult <SieveResponseModel <EducationProgramInfoViewModel> > > GetWithMoreInfo([FromQuery] SieveModel sieveModel) => await base.GetWithMoreInfo(sieveModel);
public static IQueryable <TEntity> Apply <TEntity>(this ISieveProcessor sieveProcessor, SieveModel model,
IQueryable <TEntity> source, out int totalCount, object[] dataForCustomMethods = null) where TEntity : AuditableEntity
{
source = sieveProcessor.Apply(model, source, dataForCustomMethods, applyPagination: false);
totalCount = source.Count();
source = sieveProcessor.Apply(model, source, dataForCustomMethods, applyFiltering: false, applySorting: false);
return(source);
}
public new async Task <ActionResult <SieveResponseModel <DepartmentInfoViewModel> > > GetWithMoreInfo([FromQuery] SieveModel sieveModel) => await base.GetWithMoreInfo(sieveModel);
public async Task <SieveResult <ExamsGradesSpreadsheetInfo> > GetSomeWithInfoAsync(SieveModel model)
{
if (model == null)
{
return(null);
}
var examsGradesSpreadsheetsQuery = _context.Set <Entities.ExamsGradesSpreadsheet>().AsNoTracking();
examsGradesSpreadsheetsQuery = _sieveProcessor.Apply(model, examsGradesSpreadsheetsQuery, applyPagination: false);
var result = new SieveResult <Dtos.ExamsGradesSpreadsheetInfo>();
result.TotalCount = await examsGradesSpreadsheetsQuery.CountAsync();
var someExamsGradesSpreadsheets = _sieveProcessor.Apply(model, examsGradesSpreadsheetsQuery, applyFiltering: false, applySorting: false);
result.Result = someExamsGradesSpreadsheets.Select(egs => new Dtos.ExamsGradesSpreadsheetInfo
{
CreatedAt = egs.CreatedAt,
StructuralUnitId = egs.StructuralUnitId,
Id = egs.Id,
UpdatedAt = egs.UpdatedAt,
SpreadsheetNumber = egs.SpreadsheetNumber,
SpecialtyId = egs.SpecialtyId,
SemesterNumber = egs.SemesterNumber,
FormOfEducationId = egs.FormOfEducationId,
ExamsSpreadsheetType = egs.ExamsSpreadsheetType,
ExamsSpreadsheetAttestationType = egs.ExamsSpreadsheetAttestationType,
ExamDate = egs.ExamDate,
EducationProgramId = egs.EducationProgramId,
AcademicGroupId = egs.AcademicGroupId,
AcademicDisciplineId = egs.AcademicDisciplineId,
DisciplineName = egs.AcademicDiscipline.FullName,
GroupCode = egs.AcademicGroup.Code,
NameOfFormOfEducation = egs.FormOfEducation.Name,
SpecialtyName = egs.Specialty.Name,
StructuralUnitName = egs.StructuralUnit.FullName
});
return(result);
}
public async Task <IActionResult> GetAllByCoachId(Guid id, [FromQuery] SieveModel sieveModel)
{
return(await GetQuery(async() => await Mediator.Send(new GetAllAthletesRequest(id)), sieveModel));
}
public async Task <AdvancedGetIssueTicketResponse> AdvancedGetIssueTicket(string sorts, string filters, int?page, int?pageSize)
{
//Build model for SieveProcessor
var sieveModel = new SieveModel()
{
PageSize = pageSize,
Sorts = sorts,
Page = page,
Filters = filters
};
//Get all IssueTickets
var issueTickets = await _repoWrapper.IssueTicket.FindAllAsync();
if (issueTickets == null || issueTickets.Any() == false)
{
return(new AdvancedGetIssueTicketResponse()
{
ResultList = null,
CurrentPage = 1,
TotalPage = 1
});
}
var resultResponses = new List <GetIssueTicketResponse>();
var types = await _paramService.FindAllParamEntitiesByParamType(GlobalParams.ParamTypeIssueType);
foreach (var issueTicket in issueTickets)
{
var type = types.Find(t => t.ParamId == issueTicket.Type);
var owner = await _repoWrapper.Student.FindByIdAsync(issueTicket.OwnerId);
Equipment equipment = null;
if (issueTicket.EquipmentId != null)
{
equipment = await _repoWrapper.Equipment.FindByIdAsync(issueTicket.EquipmentId.Value);
}
Param equipmentType = null;
Room room = null;
if (equipment != null)
{
equipmentType = await _repoWrapper.Param.FindByIdAsync(equipment.EquipmentTypeId);
if (equipment.RoomId != null)
{
room = await _repoWrapper.Room.FindByIdAsync(equipment.RoomId.Value);
}
}
resultResponses.Add(GetIssueTicketResponse.ResponseFromEntity(issueTicket, owner, type, equipment, equipmentType, room));
}
//Apply filter, sort
var result = _sieveProcessor.Apply(sieveModel, resultResponses.AsQueryable(), applyPagination: false).ToList();
var response = new AdvancedGetIssueTicketResponse()
{
CurrentPage = page ?? 1,
TotalPage = (int)Math.Ceiling((double)result.Count / pageSize ?? 1),
//Apply pagination
ResultList = _sieveProcessor
.Apply(sieveModel, result.AsQueryable(), applyFiltering: false, applySorting: false).ToList()
};
//Return List of result
return(response);
}
public new async Task <ActionResult <SieveResponseModel <ExamsGradesSpreadsheetInfoViewModel> > > GetWithMoreInfo([FromQuery] SieveModel sieveModel) => await base.GetWithMoreInfo(sieveModel);
public new async Task <ActionResult <SieveResponseModel <AcademicDisciplineInfoViewModel> > > GetWithMoreInfo([FromQuery] SieveModel sieveModel) => await base.GetWithMoreInfo(sieveModel);
public static PagedResult <T> GetPaged <T>(this ISieveProcessor sieveProcessor, IQueryable <T> query, SieveModel sieveModel = null) where T : class
{
var result = new PagedResult <T>();
var(pagedQuery, page, pageSize, rowCount, pageCount) = GetPagedResultAsync(sieveProcessor, query, sieveModel);
result.PageNumber = page;
result.PageSize = pageSize;
result.TotalNumberOfRecords = rowCount;
result.TotalNumberOfPages = pageCount;
result.Results = pagedQuery.ToList();
return(result);
}
public async Task <ActionResult <Voting> > Index([FromQuery] SieveModel sieveModel)
{
return(Ok(await _service.GetAllVoting(sieveModel)));
}
public FilterOptions()
{
_sieveModel = new SieveModel();
}
public static void Get([ApiConventionNameMatch(ApiConventionNameMatchBehavior.Suffix)][ApiConventionTypeMatch(ApiConventionTypeMatchBehavior.AssignableFrom)] Guid Id,
[ApiConventionNameMatch(ApiConventionNameMatchBehavior.Suffix)][ApiConventionTypeMatch(ApiConventionTypeMatchBehavior.AssignableFrom)] SieveModel sieveModel)
{
}
public static PaginationResult <M> ApplyOrderingAndPagination <M>(this ISieveProcessor sieveProcessor, SieveModel sieveModel, IQueryable <M> source)
{
int totalItems = source.Count();
var items = sieveProcessor.Apply(sieveModel, source, applyFiltering: false);
int itemsInPage = items.Count();
var formatSieveModel = SieveModelPageFormating(sieveModel);
int totalPages = (int)Math.Ceiling(totalItems / (float)formatSieveModel.PageSize);
return(new PaginationResult <M>
{
Items = items,
PageInfo = new PageInfo
{
CurrentPage = formatSieveModel.Page,
PageSize = formatSieveModel.PageSize > itemsInPage?itemsInPage:formatSieveModel.PageSize,
TotalItems = totalItems,
TotalPages = totalPages
}
});
}
public async Task <SieveResult <RatingForDisciplineInfo> > GetSomeWithInfoAsync(SieveModel model)
{
if (model == null)
{
return(null);
}
var ratingForDisciplinesQuery = _context.Set <Entities.RatingForDiscipline>()
.Include(rfd => rfd.AcademicDiscipline)
.Include(rfd => rfd.AcademicGroup)
.Include(rfd => rfd.ExamsGradesSpreadsheet)
.Include(rfd => rfd.Student)
.ThenInclude(st => st.UserInfo)
.Include(rfd => rfd.Teacher)
.ThenInclude(t => t.UserInfo)
.AsNoTracking();
ratingForDisciplinesQuery = _sieveProcessor.Apply(model, ratingForDisciplinesQuery, applyPagination: false);
var result = new SieveResult <Dtos.RatingForDisciplineInfo>();
result.TotalCount = await ratingForDisciplinesQuery.CountAsync();
var someRatingForDisciplines = _sieveProcessor.Apply(model, ratingForDisciplinesQuery, applyFiltering: false, applySorting: false);
result.Result = someRatingForDisciplines.Select(rfd => new Dtos.RatingForDisciplineInfo
{
Id = rfd.Id,
CreatedAt = rfd.CreatedAt,
UpdatedAt = rfd.UpdatedAt,
TeacherId = rfd.TeacherId,
StudentId = rfd.StudentId,
Score = rfd.Score,
ExamsGradesSpreadsheetId = rfd.ExamsGradesSpreadsheetId,
Date = rfd.Date,
AcademicGroupId = rfd.AcademicGroupId,
AcademicDisciplineId = rfd.AcademicDisciplineId,
AcademicDisciplineName = rfd.AcademicDiscipline.FullName,
AcademicGroupCode = rfd.AcademicGroup.Code,
ExamsGradesSpreadsheetNumber = rfd.ExamsGradesSpreadsheet.SpreadsheetNumber,
StudentName = rfd.Student.UserInfo.LastName + ' ' + rfd.Student.UserInfo.FirstName + ' ' + rfd.Student.UserInfo.Patronymic,
TeacherName = rfd.Teacher.UserInfo.LastName + ' ' + rfd.Teacher.UserInfo.FirstName + ' ' + rfd.Teacher.UserInfo.Patronymic,
});
return(result);
}
public async Task <SieveResult <AcademicDisciplineInfo> > GetSomeWithInfoAsync(SieveModel model)
{
if (model == null)
{
return(null);
}
var disciplinesQuery = _context.Set <Entities.AcademicDiscipline>()
.Include(ad => ad.Department)
.Include(ad => ad.Specialty)
.Include(ad => ad.Assistant)
.ThenInclude(ass => ass.UserInfo)
.Include(ad => ad.Lecturer)
.ThenInclude(lec => lec.UserInfo)
.AsNoTracking();
disciplinesQuery = _sieveProcessor.Apply(model, disciplinesQuery, applyPagination: false);
var result = new SieveResult <Dtos.AcademicDisciplineInfo>();
result.TotalCount = await disciplinesQuery.CountAsync();
var someDisciplines = _sieveProcessor.Apply(model, disciplinesQuery, applyFiltering: false, applySorting: false);
result.Result = someDisciplines.Select(discipline => new Dtos.AcademicDisciplineInfo
{
AssistantId = discipline.AssistantId,
Attestation = discipline.Attestation,
CreatedAt = discipline.CreatedAt,
CurriculumId = discipline.CurriculumId,
DepartmentId = discipline.DepartmentId,
FullName = discipline.FullName,
Id = discipline.Id,
LecturerId = discipline.LecturerId,
Semester = discipline.Semester,
NumberOfCredits = discipline.NumberOfCredits,
ShortName = discipline.ShortName,
SpecialtyId = discipline.SpecialtyId,
TypeOfIndividualWork = discipline.TypeOfIndividualWork,
UpdatedAt = discipline.UpdatedAt,
DepartmentName = discipline.Department.FullName,
SpecialtyName = discipline.Specialty.Name,
AssistantName = discipline.Assistant.UserInfo.LastName + ' ' + discipline.Assistant.UserInfo.FirstName + ' ' + discipline.Assistant.UserInfo.Patronymic,
LecturerName = discipline.Lecturer.UserInfo.LastName + ' ' + discipline.Lecturer.UserInfo.FirstName + ' ' + discipline.Lecturer.UserInfo.Patronymic
});
return(result);
}
public async Task <ActionResult <IEnumerable <BoardMeetingViewDto> > > GetBoardMeetings([FromQuery] SieveModel sieveModel)
{
//throw new Exception($"Error saving BoardMeeting to the database");
//var boardMeetings = await _boardMeetingRepository.GetBoardMeetingsAsync(sieveModel);
//var boardMeetingsToReturn = _mapper.Map<IEnumerable<BoardMeetingViewDto>>(boardMeetings);
var boardMeetings = _boardMeetingRepository.GetBoardMeetings();
var boardMeetingsToReturn = _mapper.Map <IEnumerable <BoardMeetingViewDto> >(await _sortFilterService.ApplySortsFilters(boardMeetings, sieveModel));
return(Ok(boardMeetingsToReturn));
}
protected virtual IQueryable <TEntity> ApplyFilterAndSort(SieveModel sieveModel, IQueryable <TEntity> source)
{
return(_sieveProcessor.Apply(sieveModel, source,
applyPagination: false));
}
public new async Task <ActionResult <SieveResponseModel <FormOfEducationViewModel> > > Get([FromQuery] SieveModel sieveModel) => await base.Get(sieveModel);
public Query(
SieveModel sieveModel)
{
SieveModel = sieveModel;
}
public new async Task <ActionResult <SieveResponseModel <StructuralUnitViewModel> > > Get([FromQuery] SieveModel sieveModel) => await base.Get(sieveModel);
public async Task<ActionResult<IEnumerable<CommentViewDto>>> GetCommentsForPost([FromRoute] Guid postId, [FromQuery] SieveModel sieveModel)
{
if (!await _postRepository.PostExistsAsync(postId))
{
return NotFound();
}
var commentsFromRepo = _commentRepository.GetComments(postId);
var commentsToReturn = _mapper.Map<IEnumerable<CommentViewDto>>(await _sortFilterService.ApplySortsFilters(commentsFromRepo, sieveModel));
return Ok(commentsToReturn);
}
public async Task <PaginatedList <AssetStockTakingDetailDto> > StockTakingDetailPagination(SieveModel model, Guid assetStockTakingOrgId)
{
var detailsQueryable =
from n in _assetStockTakingDetailRepository.GetAll(it =>
it.AssetStockTakingOrganizationId == assetStockTakingOrgId)
select n;
var mapperResult = detailsQueryable.ProjectTo <AssetStockTakingDetailDto>(_mapper.ConfigurationProvider);
var count = await _sieveProcessor.Apply(model, mapperResult, applyPagination : false).CountAsync();
var paginatedList = _sieveProcessor.Apply(model, mapperResult);
return(new PaginatedList <AssetStockTakingDetailDto>(_sieveOptions, model.Page, model.PageSize, count, paginatedList));
}
public virtual Task <int> CountAsync(SieveModel sieveModel, CancellationToken cancellationToken = default)
{
var query = DbSet.AsNoTracking();
return(SieveProcessor.Apply(sieveModel, query).CountAsync(cancellationToken));
}
/// <summary>
/// 查询某个资产盘点任务下面的所有参与机构
/// </summary>
/// <param name="model"></param>
/// <param name="stockTakingId"></param>
/// <returns></returns>
public async Task <PaginatedList <AssetStockTakingOrgDto> > AssetStockTakingOrgPagination(SieveModel model, Guid stockTakingId)
{
var organizations = _stockTakingOrgRepository.GetAll(it => it.AssetStockTakingId == stockTakingId);
var count = await _sieveProcessor.Apply(model, organizations, applyPagination : false).CountAsync();
var mappingResult = _sieveProcessor.Apply(model, organizations);
var pagination = await mappingResult.ToListAsync();
var mapperResult = _mapper.Map <IEnumerable <AssetStockTakingOrgDto> >(pagination);
return(new PaginatedList <AssetStockTakingOrgDto>(
_sieveOptions, model.Page, model.PageSize, count, mapperResult));
}
public new async Task <ActionResult <SieveResponseModel <TeacherViewModel> > > Get([FromQuery] SieveModel sieveModel) => await base.Get(sieveModel);
public static IQueryable <M> ApplySorting <M> (this ISieveProcessor sieveProcessor, SieveModel sieveModel, IQueryable <M> source)
{
return(sieveProcessor.Apply(sieveModel, source, applyPagination: false, applySorting: false));
}
public async Task <List <RoleDto> > Get(
SieveModel sieveModel)
{
return(await _mediator.Send(new UserList.Query(sieveModel)));
}
public async Task <IActionResult> GetAll([FromQuery] SieveModel sieveModel)
{
return(await GetQuery(async() => await Mediator.Send(new GetAllCoachsRequest()), sieveModel));
}
