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