/// <summary> /// 定义是否允许点击列表头进行排序 /// </summary> /// <param name = "sortable"></param> /// <param name = "sortType">当datatype为local时有效。定义适当的排序类型。</param> public Column SetSortable(bool sortable, SortType sortType = SortType.Text, SortOrder firstSortOrder = SortOrder.Asc) { _sortable = sortable; _sortType = sortType; _firstSortOrder = firstSortOrder; return this; }
/// <inheritdoc cref="ISort.Order" /> public virtual TDescriptor Order(SortOrder?order) => Assign(order, (a, v) => a.Order = v);
public async Task OnGetAsync(SortOrder?sort, int teamId, PuzzleStateFilter?stateFilter) { TeamID = teamId; Team myTeam = await UserEventHelper.GetTeamForPlayer(_context, Event, LoggedInUser); if (myTeam != null) { TeamID = myTeam.ID; TeamPassword = myTeam.Password; await PuzzleStateHelper.CheckForTimedUnlocksAsync(_context, Event, myTeam); } else { throw new Exception("Not currently registered for a team"); } this.Sort = sort; this.StateFilter = stateFilter; ShowAnswers = Event.AnswersAvailableBegin <= DateTime.UtcNow; AllowFeedback = Event.AllowFeedback; // all puzzles for this event that are real puzzles var puzzlesInEventQ = _context.Puzzles.Where(puzzle => puzzle.Event.ID == this.Event.ID && puzzle.IsPuzzle); // unless we're in a global lockout, then filter to those! var puzzlesCausingGlobalLockoutQ = PuzzleStateHelper.PuzzlesCausingGlobalLockout(_context, Event, myTeam); if (await puzzlesCausingGlobalLockoutQ.AnyAsync()) { puzzlesInEventQ = puzzlesCausingGlobalLockoutQ; } // all puzzle states for this team that are unlocked (note: IsUnlocked bool is going to harm perf, just null check the time here) // Note that it's OK if some puzzles do not yet have a state record; those puzzles are clearly still locked and hence invisible. // All puzzles will show if all answers have been released) var stateForTeamQ = _context.PuzzleStatePerTeam.Where(state => state.TeamID == this.TeamID && (ShowAnswers || state.UnlockedTime != null)); // join 'em (note: just getting all properties for max flexibility, can pick and choose columns for perf later) // Note: EF gotcha is that you have to join into anonymous types in order to not lose valuable stuff var visiblePuzzlesQ = from Puzzle puzzle in puzzlesInEventQ join PuzzleStatePerTeam pspt in stateForTeamQ on puzzle.ID equals pspt.PuzzleID select new PuzzleView { ID = puzzle.ID, Group = puzzle.Group, OrderInGroup = puzzle.OrderInGroup, Name = puzzle.Name, CustomUrl = puzzle.CustomURL, Errata = puzzle.Errata, SolvedTime = pspt.SolvedTime, PieceMetaUsage = puzzle.PieceMetaUsage }; switch (sort ?? DefaultSort) { case SortOrder.PuzzleAscending: visiblePuzzlesQ = visiblePuzzlesQ.OrderBy(pv => pv.Name); break; case SortOrder.PuzzleDescending: visiblePuzzlesQ = visiblePuzzlesQ.OrderByDescending(pv => pv.Name); break; case SortOrder.GroupAscending: visiblePuzzlesQ = visiblePuzzlesQ.OrderBy(pv => pv.Group).ThenBy(pv => pv.OrderInGroup).ThenBy(pv => pv.Name); break; case SortOrder.GroupDescending: visiblePuzzlesQ = visiblePuzzlesQ.OrderByDescending(pv => pv.Group).ThenByDescending(pv => pv.OrderInGroup).ThenByDescending(pv => pv.Name); break; case SortOrder.SolveAscending: visiblePuzzlesQ = visiblePuzzlesQ.OrderBy(pv => pv.SolvedTime ?? DateTime.MaxValue); break; case SortOrder.SolveDescending: visiblePuzzlesQ = visiblePuzzlesQ.OrderByDescending(pv => pv.SolvedTime ?? DateTime.MaxValue); break; default: throw new ArgumentException($"unknown sort: {sort}"); } if (this.StateFilter == PuzzleStateFilter.Unsolved) { visiblePuzzlesQ = visiblePuzzlesQ.Where(puzzles => puzzles.SolvedTime == null); } PuzzleViews = await visiblePuzzlesQ.ToListAsync(); Dictionary <int, ContentFile> files = await(from file in _context.ContentFiles where file.Event == Event && file.FileType == ContentFileType.Puzzle select file).ToDictionaryAsync(file => file.PuzzleID); foreach (var puzzleView in PuzzleViews) { files.TryGetValue(puzzleView.ID, out ContentFile content); puzzleView.Content = content; } if (ShowAnswers) { Dictionary <int, ContentFile> answers = await(from file in _context.ContentFiles where file.Event == Event && file.FileType == ContentFileType.Answer select file).ToDictionaryAsync(file => file.PuzzleID); foreach (var puzzleView in PuzzleViews) { answers.TryGetValue(puzzleView.ID, out ContentFile answer); puzzleView.Answer = answer; } } }
private static string GetQuery(List <FolderFilter> filters, int?limit, int?offset, SortBy?sortBy, SortOrder?sortOrder) { var uri = new UriBuilder(SkyDriveBaseUrl + SkyDriveConstants.GetFiles); var filterString = ParseFilters(filters); uri.SetQueryParam(SkyDriveConstants.Filters, filterString); if (limit.HasValue) { uri.SetQueryParam(LiveSdkConstants.Limit, limit.Value.ToString()); } if (offset.HasValue) { uri.SetQueryParam(LiveSdkConstants.Offset, offset.Value.ToString()); } if (sortBy.HasValue) { uri.SetQueryParam(SkyDriveConstants.SortBy, sortBy.ToString().ToLower()); } if (sortOrder.HasValue) { uri.SetQueryParam(SkyDriveConstants.SortOrder, sortBy.ToString().ToLower()); } return(uri.Query); }
/// <summary> /// If set to asc or desc, the column will be sorted in that direction on first /// sort.Subsequent sorts of the column will toggle as usual (default: null) /// </summary> /// <param name = "firstSortOrder">First sort order</param> public Column SetFirstSortOrder(SortOrder firstSortOrder) { _firstSortOrder = firstSortOrder; return(this); }
public void Filter(int?idGroup, int?idYear, string lastname, string activeGroups, int?privilege, DateTime dtStart, DateTime dtEnd, string column, SortOrder?sortOrder) { try { listStudents = from enroll in db.Enrollments join privileges in db.Privileges on enroll.PrivilegeId equals privileges.Id into g from privileges in g.DefaultIfEmpty() join groups in db.Groups on enroll.GroupId equals groups.Id join activity in db.ActivityGroups on groups.ActivityId equals activity.Id join students in db.Students on enroll.StudentId equals students.Id join statuses in db.Statuses on students.StatusId equals statuses.Id join years in db.Years on groups.YearId equals years.Id where enroll.DateExclusion == null && enroll.ExclusionId == null select new Finance { StudentId = students.Id, GroupId = groups.Id, SchoolId = students.SchoolId, EnrollId = enroll.Id, PrivilegeId = enroll.PrivilegeId, ActivityId = activity.Id, YearId = years.Id, Activity = activity.Name, StatusId = students.StatusId, Lastname = students.Lastname, Firstname = students.Firstname, Middlename = students.Middlename, Sex = students.Sex, NameGroup = groups.Name, Year = years.Name, Status = statuses.Name, School = students.School.Name, Class = students.Class, Privilege = privileges.Name, Accrual = (from scheds in db.Schedules where scheds.Source == 2 && scheds.EnrollmentId == enroll.Id && scheds.DateBegin >= dtpStart.Value && scheds.DateBegin <= dtpEnd.Value select new { SchedsSum = scheds.Value }).Sum(s => (double?)(s.SchedsSum)) ?? 0, AccrualDiscount = (from scheds in db.Schedules where scheds.Source == 2 && scheds.EnrollmentId == enroll.Id && scheds.DateBegin >= dtpStart.Value && scheds.DateBegin <= dtpEnd.Value select new { SchedSum = scheds.Value - scheds.Discount }).Sum(s => (double?)(s.SchedSum)) ?? 0, Payment = (from pays in db.Payments where pays.EnrollmentId == enroll.Id && pays.DatePayment >= dtpStart.Value && pays.DatePayment <= dtpEnd.Value && pays.IsDeleted == false && pays.AdditionalPay == false select new { PaySum = pays.ValuePayment }).Sum(s => (double?)(s.PaySum)) ?? 0, }; if (idGroup != null) { listStudents = listStudents.Where(d => d.GroupId == idGroup); } if (lastname != null && lastname != "") { listStudents = listStudents.Where(e => e.Lastname.StartsWith(lastname)); } if (privilege != null) { listStudents = listStudents.Where(e => e.PrivilegeId == privilege); } if (idYear != null) { listStudents = listStudents.Where(e => e.YearId == idYear); } if (activeGroups == "Активные") { listStudents = listStudents.Where(a => a.Activity != "Закрытые"); } else { listStudents = listStudents.Where(a => a.Activity == activeGroups); } //сортировка if (column != null) { switch (column) { case "Lastname": { if (sortOrder == SortOrder.Ascending) { listStudents = listStudents.OrderBy(x => x.Lastname); } else { listStudents = listStudents.OrderByDescending(x => x.Lastname); } break; } case "Firstname": { if (sortOrder == SortOrder.Ascending) { listStudents = listStudents.OrderBy(x => x.Firstname); } else { listStudents = listStudents.OrderByDescending(x => x.Firstname); } break; } case "Middlename": { if (sortOrder == SortOrder.Ascending) { listStudents = listStudents.OrderBy(x => x.Middlename); } else { listStudents = listStudents.OrderByDescending(x => x.Middlename); } break; } case "Status": { if (sortOrder == SortOrder.Ascending) { listStudents = listStudents.OrderBy(x => x.Status); } else { listStudents = listStudents.OrderByDescending(x => x.Status); } break; } case "NameGroup": { if (sortOrder == SortOrder.Ascending) { listStudents = listStudents.OrderBy(x => x.NameGroup); } else { listStudents = listStudents.OrderByDescending(x => x.NameGroup); } break; } case "Privilege": { if (sortOrder == SortOrder.Ascending) { listStudents = listStudents.OrderBy(x => x.Privilege); } else { listStudents = listStudents.OrderByDescending(x => x.Privilege); } break; } case "School": { if (sortOrder == SortOrder.Ascending) { listStudents = listStudents.OrderBy(x => x.School); } else { listStudents = listStudents.OrderByDescending(x => x.School); } break; } case "Class": { if (sortOrder == SortOrder.Ascending) { listStudents = listStudents.OrderBy(x => x.Class); } else { listStudents = listStudents.OrderByDescending(x => x.Class); } break; } case "Sex": { if (sortOrder == SortOrder.Ascending) { listStudents = listStudents.OrderBy(x => x.Sex); } else { listStudents = listStudents.OrderByDescending(x => x.Sex); } break; } case "Payment": { if (sortOrder == SortOrder.Ascending) { listStudents = listStudents.OrderBy(x => x.Payment); } else { listStudents = listStudents.OrderByDescending(x => x.Payment); } break; } case "AccrualDiscount": { if (sortOrder == SortOrder.Ascending) { listStudents = listStudents.OrderBy(x => x.AccrualDiscount); } else { listStudents = listStudents.OrderByDescending(x => x.AccrualDiscount); } break; } case "Accrual": { if (sortOrder == SortOrder.Ascending) { listStudents = listStudents.OrderBy(x => x.Accrual); } else { listStudents = listStudents.OrderByDescending(x => x.Accrual); } break; } } } else { listStudents = listStudents.OrderBy(f => f.Lastname); } dgvStudents.DataSource = listStudents.ToList(); ///////////////////////расчет итогов///////////////////////////// //количество групп toolStripStatusLabel2.Text = dgvStudents.Rows.Count.ToString(); double summScheds = 0; double summPays = 0; double summDebt = 0; double summPrepayment = 0; foreach (DataGridViewRow row in dgvStudents.Rows) { //итого начислено со скидкой summScheds += (double)row.Cells["AccrualDiscount"].Value; //итого платежей summPays += (double)row.Cells["Payment"].Value; //итого долг summDebt += ((double)row.Cells["Saldo"].Value > 0) ? (double)row.Cells["Saldo"].Value : 0; //итого аванс summPrepayment += ((double)row.Cells["Saldo"].Value < 0) ? (double)row.Cells["Saldo"].Value : 0; } if (sortOrder != SortOrder.None) { dgvStudents.Columns[sortColumn].HeaderCell.SortGlyphDirection = (SortOrder)sortOrder; } toolStripStatusLabel5.Text = summScheds.ToString("C", CultureInfo.CurrentCulture); toolStripStatusLabel8.Text = summPays.ToString("C", CultureInfo.CurrentCulture); toolStripStatusLabel9.Text = summDebt.ToString("C", CultureInfo.CurrentCulture); toolStripStatusLabel11.Text = (-summPrepayment).ToString("C", CultureInfo.CurrentCulture); } catch (Exception ex) { var m = new System.Diagnostics.StackTrace(false).GetFrame(0).GetMethod(); string methodName = m.DeclaringType.ToString() + ";" + m.Name; CurrentSession.ReportError(methodName, ex.Message); MessageBox.Show(ex.Message, "Ошибка", MessageBoxButtons.OK, MessageBoxIcon.Error); } }
public async Task OnGetAsync(SortOrder?sort) { Sort = sort; var puzzleData = await _context.Puzzles .Where(p => p.Event == Event && p.IsPuzzle) .ToDictionaryAsync(p => p.ID, p => new { p.SolveValue, p.IsCheatCode, p.IsFinalPuzzle }); DateTime submissionEnd = Event.AnswerSubmissionEnd; var stateData = await PuzzleStateHelper.GetSparseQuery(_context, this.Event, null, null) .Where(pspt => pspt.SolvedTime != null && pspt.SolvedTime <= submissionEnd) .Select(pspt => new { pspt.PuzzleID, pspt.TeamID, pspt.SolvedTime }) .ToListAsync(); var teams = await _context.Teams .Where(t => t.Event == Event) .ToListAsync(); Dictionary <int, TeamStats> teamStats = new Dictionary <int, TeamStats>(teams.Count); foreach (var t in teams) { teamStats[t.ID] = new TeamStats { Team = t, FinalMetaSolveTime = DateTime.MaxValue }; } foreach (var s in stateData) { if (!puzzleData.TryGetValue(s.PuzzleID, out var p) || !teamStats.TryGetValue(s.TeamID, out var ts)) { continue; } ts.Score += p.SolveValue; ts.SolveCount++; if (p.IsCheatCode) { ts.Cheated = true; ts.FinalMetaSolveTime = DateTime.MaxValue; } if (p.IsFinalPuzzle && !ts.Cheated) { ts.FinalMetaSolveTime = s.SolvedTime.Value; } } var teamsFinal = teamStats.Values.OrderBy(t => t.FinalMetaSolveTime).ThenByDescending(t => t.Score).ThenBy(t => t.Team.Name).ToList(); TeamStats prevStats = null; for (int i = 0; i < teamsFinal.Count; i++) { var stats = teamsFinal[i]; if (prevStats == null || stats.FinalMetaSolveTime != prevStats.FinalMetaSolveTime || stats.Score != prevStats.Score) { stats.Rank = i + 1; } else { stats.Rank = prevStats.Rank; } prevStats = stats; } switch (sort) { case SortOrder.RankAscending: break; case SortOrder.RankDescending: teamsFinal.Reverse(); break; case SortOrder.NameAscending: teamsFinal = teamsFinal.OrderBy(ts => ts.Team.Name).ToList(); break; case SortOrder.NameDescending: teamsFinal = teamsFinal.OrderByDescending(ts => ts.Team.Name).ToList(); break; case SortOrder.PuzzlesAscending: teamsFinal = teamsFinal.OrderBy(ts => ts.SolveCount).ThenBy(ts => ts.Rank).ThenBy(ts => ts.Team.Name).ToList(); break; case SortOrder.PuzzlesDescending: teamsFinal = teamsFinal.OrderByDescending(ts => ts.SolveCount).ThenByDescending(ts => ts.Rank).ThenByDescending(ts => ts.Team.Name).ToList(); break; case SortOrder.ScoreAscending: teamsFinal = teamsFinal.OrderBy(ts => ts.Score).ThenBy(ts => ts.Rank).ThenBy(ts => ts.Team.Name).ToList(); break; case SortOrder.ScoreDescending: teamsFinal = teamsFinal.OrderByDescending(ts => ts.Score).ThenByDescending(ts => ts.Rank).ThenByDescending(ts => ts.Team.Name).ToList(); break; case SortOrder.HintsUsedAscending: teamsFinal = teamsFinal.OrderBy(ts => ts.Team.HintCoinsUsed).ThenBy(ts => ts.Rank).ThenBy(ts => ts.Team.Name).ToList(); break; case SortOrder.HintsUsedDescending: teamsFinal = teamsFinal.OrderByDescending(ts => ts.Team.HintCoinsUsed).ThenByDescending(ts => ts.Rank).ThenByDescending(ts => ts.Team.Name).ToList(); break; } this.Teams = teamsFinal; }
public Grid SetDefaultSorting(string sortField, SortOrder sortOrder) { _sortField = sortField; _sortOrder = sortOrder; return(this); }
/// <summary> /// Searches for items /// </summary> /// <param name="searchTerm">The search term.</param> /// <param name="genreId">The genre to filter the results by.</param> /// <param name="id">An artist or product id.</param> /// <param name="category">The category to filter the results by.</param> /// <param name="location">The location to filter the results by.</param> /// <param name="maxdistance">The max distance from the location to to filter the results by.</param> /// <param name="orderBy">The field to sort the items by.</param> /// <param name="sortOrder">The sort order of the items to fetch.</param> /// <param name="startIndex">The zero-based start index to fetch items from (e.g. to get the second page of 10 items, pass in 10).</param> /// <param name="itemsPerPage">The number of items to fetch.</param> /// <returns>A response</returns> protected List <KeyValuePair <string, string> > BuildQueryStringParams(string searchTerm, string genreId, string id, Category?category, string location, string maxdistance, OrderBy?orderBy, SortOrder?sortOrder, int startIndex, int itemsPerPage) { // Build querystring parameters... var parameters = this.GetPagingParams(); if (!string.IsNullOrEmpty(searchTerm)) { parameters.Add(new KeyValuePair <string, string>(ParamSearchTerm, searchTerm)); } if (!string.IsNullOrEmpty(genreId)) { parameters.Add(new KeyValuePair <string, string>(ParamGenre, genreId)); } if (!string.IsNullOrEmpty(id)) { parameters.Add(new KeyValuePair <string, string>(ParamId, id)); } if (category.HasValue && category != Types.Category.Unknown) { foreach (var value in Enum.GetValues(typeof(Category))) { var availableCategory = (Category)value; if (availableCategory == Types.Category.Unknown) { continue; } if ((category & availableCategory) == availableCategory) { parameters.Add(new KeyValuePair <string, string>( ParamCategory, availableCategory.ToString().ToLowerInvariant())); } } } if (orderBy.HasValue) { parameters.Add(new KeyValuePair <string, string>(ParamOrderBy, orderBy.Value.ToString().ToLowerInvariant())); } if (sortOrder.HasValue) { parameters.Add(new KeyValuePair <string, string>(ParamSortOrder, sortOrder.Value.ToString().ToLowerInvariant())); } if (!string.IsNullOrEmpty(location)) { parameters.Add(new KeyValuePair <string, string>(ParamLocation, location)); } if (!string.IsNullOrEmpty(maxdistance)) { parameters.Add(new KeyValuePair <string, string>(ParamMaxDistance, maxdistance)); } return(parameters); }
public static SortOrder Invert(this SortOrder?sortOrder, SortOrder @default = SortOrder.Asc) { return(sortOrder.GetValueOrDefault(@default) == SortOrder.Asc ? SortOrder.Desc : SortOrder.Asc); }
public IEnumerable <T> GetAll <T1>(Expression <Func <T, bool> > filterExpression, Expression <Func <T, T1> > sortExpression, SortOrder?sortOrder = null) { return(this.GetAll <T1, T>(filterExpression, sortExpression, sortOrder, null)); }
public void Filter(string lastname, int?idGroup, DateTime?dateEnrollment, DateTime?dateExclusion, int?typeId, string column, bool transfer, SortOrder?sortOrder) { listStudents = from enroll in db.Enrollments join groups in db.Groups on enroll.GroupId equals groups.Id join activity in db.ActivityGroups on groups.ActivityId equals activity.Id join students in db.Students on enroll.StudentId equals students.Id join schools in db.Schools on students.SchoolId equals schools.Id into outer2 from schools in outer2.DefaultIfEmpty() join causes in db.Causes on enroll.CauseId equals causes.Id into outer1 from causes in outer1.DefaultIfEmpty() join months in db.Months on enroll.MonthExclusionId equals months.Id into outer from months in outer.DefaultIfEmpty() join teachers in db.Workers on groups.TeacherId equals teachers.Id into outer3 from teachers in outer3.DefaultIfEmpty() join years in db.Years on groups.YearId equals years.Id into outer4 from years in outer4.DefaultIfEmpty() where enroll.Group.ActivityId == 1 || enroll.ExclusionId != null select new Archive { StudentId = students.Id, GroupId = groups.Id, SchoolId = students.SchoolId, EnrollId = enroll.Id, YearId = years.Id, ActivityId = activity.Id, Lastname = students.Lastname, Firstname = students.Firstname, Middlename = students.Middlename, NameGroup = groups.Name, Year = years.Name, Status = activity.Name, Teacher = teachers.Lastname + " " + teachers.Firstname.Substring(0, 1) + "." + teachers.Middlename.Substring(0, 1) + ".", DateEnrollment = enroll.DateEnrollment, DateExclusion = enroll.DateExclusion, Cause = causes.Name, Transfer = enroll.Transfer, Note = enroll.Note, Phone1 = students.StudentPhone, Phone2 = students.StudentPhone2, ParentPhone = students.ParentsPhone, Sex = students.Sex, BirthDate = students.DateOfBirth, School = schools.Name, Class = students.Class }; if (typeId != null) { listStudents = listStudents.Where(d => d.YearId == typeId); } if (idGroup != null) { listStudents = listStudents.Where(d => d.GroupId == idGroup); } if (lastname != null && lastname != "") { listStudents = listStudents.Where(e => e.Lastname.StartsWith(lastname)); } if (dateBegin) { listStudents = listStudents.Where(a => a.DateExclusion.Value >= dtpDateBegin.Value.Date); } if (dateEnd) { listStudents = listStudents.Where(a => a.DateExclusion.Value <= dtpDateEnd.Value.Date); } if (transfer) { listStudents = listStudents.Where(a => a.Transfer == true); } else { listStudents = listStudents.Where(a => a.Transfer == false); } //сортировка if (column != null) { switch (column) { case "Lastname": { if (sortOrder == SortOrder.Ascending) { listStudents = listStudents.OrderBy(x => x.Lastname); } else { listStudents = listStudents.OrderByDescending(x => x.Lastname); } break; } case "Firstname": { if (sortOrder == SortOrder.Ascending) { listStudents = listStudents.OrderBy(x => x.Firstname); } else { listStudents = listStudents.OrderByDescending(x => x.Firstname); } break; } case "Middlename": { if (sortOrder == SortOrder.Ascending) { listStudents = listStudents.OrderBy(x => x.Middlename); } else { listStudents = listStudents.OrderByDescending(x => x.Middlename); } break; } case "Status": { if (sortOrder == SortOrder.Ascending) { listStudents = listStudents.OrderBy(x => x.Status); } else { listStudents = listStudents.OrderByDescending(x => x.Status); } break; } case "NameGroup": { if (sortOrder == SortOrder.Ascending) { listStudents = listStudents.OrderBy(x => x.NameGroup); } else { listStudents = listStudents.OrderByDescending(x => x.NameGroup); } break; } case "Teacher": { if (sortOrder == SortOrder.Ascending) { listStudents = listStudents.OrderBy(x => x.Teacher); } else { listStudents = listStudents.OrderByDescending(x => x.Teacher); } break; } case "Phone1": { if (sortOrder == SortOrder.Ascending) { listStudents = listStudents.OrderBy(x => x.Phone1); } else { listStudents = listStudents.OrderByDescending(x => x.Phone1); } break; } case "Phone2": { if (sortOrder == SortOrder.Ascending) { listStudents = listStudents.OrderBy(x => x.Phone2); } else { listStudents = listStudents.OrderByDescending(x => x.Phone2); } break; } case "ParentPhone": { if (sortOrder == SortOrder.Ascending) { listStudents = listStudents.OrderBy(x => x.ParentPhone); } else { listStudents = listStudents.OrderByDescending(x => x.ParentPhone); } break; } case "BirthDate": { if (sortOrder == SortOrder.Ascending) { listStudents = listStudents.OrderBy(x => x.BirthDate); } else { listStudents = listStudents.OrderByDescending(x => x.BirthDate); } break; } case "School": { if (sortOrder == SortOrder.Ascending) { listStudents = listStudents.OrderBy(x => x.School); } else { listStudents = listStudents.OrderByDescending(x => x.School); } break; } case "Class": { if (sortOrder == SortOrder.Ascending) { listStudents = listStudents.OrderBy(x => x.Class); } else { listStudents = listStudents.OrderByDescending(x => x.Class); } break; } case "Transfer": { if (sortOrder == SortOrder.Ascending) { listStudents = listStudents.OrderBy(x => x.Transfer); } else { listStudents = listStudents.OrderByDescending(x => x.Transfer); } break; } case "Note": { if (sortOrder == SortOrder.Ascending) { listStudents = listStudents.OrderBy(x => x.Note); } else { listStudents = listStudents.OrderByDescending(x => x.Note); } break; } case "DateExclusion": { if (sortOrder == SortOrder.Ascending) { listStudents = listStudents.OrderBy(x => x.DateExclusion); } else { listStudents = listStudents.OrderByDescending(x => x.DateExclusion); } break; } case "DateEnrollment": { if (sortOrder == SortOrder.Ascending) { listStudents = listStudents.OrderBy(x => x.DateEnrollment); } else { listStudents = listStudents.OrderByDescending(x => x.DateEnrollment); } break; } case "Cause": { if (sortOrder == SortOrder.Ascending) { listStudents = listStudents.OrderBy(x => x.Cause); } else { listStudents = listStudents.OrderByDescending(x => x.Cause); } break; } case "Sex": { if (sortOrder == SortOrder.Ascending) { listStudents = listStudents.OrderBy(x => x.Sex); } else { listStudents = listStudents.OrderByDescending(x => x.Sex); } break; } } } else { listStudents = listStudents.OrderBy(f => f.Lastname); } dgvStudents.DataSource = listStudents.ToList(); if (sortOrder != SortOrder.None) { dgvStudents.Columns[sortColumn].HeaderCell.SortGlyphDirection = (SortOrder)sortOrder; } }
public async Task <IActionResult> Get(int?pageNumber, int?pageSize, string?sortBy, SortOrder?sortDirection) { this.logger.LogInformation("Getting all search queries..."); var pageRequest = new PageRequest { PageNumber = pageNumber ?? 1, PageSize = pageSize ?? 10, Sort = new Sort { Property = sortBy ?? "id", Order = sortDirection ?? SortOrder.Ascending } }; var queryable = this.queries.GetSummaries(); if (pageRequest.Sort != null) { queryable = queryable.OrderBy(new[] { pageRequest.Sort }); } queryable = queryable .Skip((pageRequest.PageNumber - 1) * pageRequest.PageSize) .Take(pageRequest.PageSize); var page = new Page <SearchQuerySummary> { PageNumber = pageRequest.PageNumber, PageSize = pageRequest.PageSize, TotalItems = await this.queries.GetSummaries().CountAsync(), Items = await queryable.ToListAsync(), Sort = pageRequest.Sort ?? new Sort { Property = "id" } }; return(this.Ok(page)); }
public IReadOnlyList <TModel> GetAllByFilterAndPage(Specification <TModel, bool> specification, Specification <TModel, object> orderSpecification = null, SortOrder?sortOrder = null, int?pageNumber = 0) { if (orderSpecification == null || sortOrder == null) { return(DbContext.Set <TModel>() .Where(specification?.ToExpression() ?? throw new InvalidOperationException()) .OrderBy("CreatedDate") .Skip(PageSize * pageNumber ?? 0) .Take(PageSize)? .ToList() as List <TModel>); } else { if (sortOrder == SortOrder.Asc) { return(DbContext.Set <TModel>() .Where(specification?.ToExpression() ?? throw new InvalidOperationException()) .OrderBy(orderSpecification?.ToExpression() ?? throw new InvalidOperationException()) .Skip(PageSize * pageNumber ?? 0) .Take(PageSize)? .ToList() as List <TModel>); } else { return(DbContext.Set <TModel>() .Where(specification?.ToExpression() ?? throw new InvalidOperationException()) .OrderByDescending(orderSpecification?.ToExpression() ?? throw new InvalidOperationException()) .Skip(PageSize * pageNumber ?? 0) .Take(PageSize)? .ToList() as List <TModel>); } } }
/// <summary> /// The initial sorting order when we use datatypes xml or json (data returned from server). /// This parameter is added to the url. Two possible values - asc or desc. (default: asc) /// </summary> /// <param name="sortOrder">Sortorder</param> public Grid SetSortOrder(SortOrder sortOrder) { this.sortOrder = sortOrder; return this; }
private void Filter(int?directionId, string name, int?type, string activeGroupsName, string column, DateTime dtStart, DateTime dtEnd, SortOrder?sortOrder) { try { var listGroups = from groups in db.Groups join courses in db.Courses on groups.CourseId equals courses.Id join directions in db.Directions on courses.DirectionId equals directions.Id join teachers in db.Workers on groups.TeacherId equals teachers.Id into outerTeacher from teachers in outerTeacher.DefaultIfEmpty() join activities in db.ActivityGroups on groups.ActivityId equals activities.Id join years in db.Years on groups.YearId equals years.Id into outer from years in outer.DefaultIfEmpty() select new FinanceGroups { GroupId = groups.Id, DirectionId = directions.Id, Direction = directions.Name, ActivityId = activities.Id, YearId = years.Id, CourseName = courses.Name, Name = groups.Name, Year = years.Name, StudentsP = groups.PlanEnroll, StudentsF = db.Enrollments.Where(a => a.GroupId == groups.Id && a.DateExclusion == null).Count(), Activity = activities.Name, Price = db.Schedules.Where(a => a.GroupId == groups.Id && a.Source == 2 && a.EnrollmentId == null && a.DateBegin >= dtpStart.Value.Date && a.DateBegin <= dtpEnd.Value.Date).Select(a => new { a.Value }).Sum(s => (double?)(s.Value)) ?? 0, Accrual = (from scheds in db.Schedules join enrolls in db.Enrollments on scheds.EnrollmentId equals enrolls.Id where scheds.Source == 2 && scheds.EnrollmentId != null && scheds.GroupId == groups.Id && enrolls.DateExclusion == null && scheds.DateBegin >= dtpStart.Value.Date && scheds.DateBegin <= dtpEnd.Value.Date select new { SchedSum = scheds.Value }).Sum(s => (double?)(s.SchedSum)) ?? 0, AccrualDiscount = (Double?)(from scheds in db.Schedules join enrolls in db.Enrollments on scheds.EnrollmentId equals enrolls.Id where scheds.Source == 2 && scheds.EnrollmentId != null && scheds.GroupId == groups.Id && enrolls.DateExclusion == null && scheds.DateBegin >= dtpStart.Value.Date && scheds.DateBegin <= dtpEnd.Value.Date select new { SchedSum = scheds.Value - scheds.Discount }).Sum(s => (double?)(s.SchedSum)) ?? 0, Payment = (Double?)(from pays in db.Payments join enrolls in db.Enrollments on pays.EnrollmentId equals enrolls.Id where enrolls.GroupId == groups.Id && enrolls.DateExclusion == null && pays.IsDeleted == false && pays.AdditionalPay == false && pays.DatePayment >= dtpStart.Value && pays.DatePayment <= dtpEnd.Value select new { PaySum = pays.ValuePayment }).Sum(s => (double?)(s.PaySum)) ?? 0, }; if (directionId != null) { listGroups = listGroups.Where(d => d.DirectionId == directionId); } if (name != null && name != "") { listGroups = listGroups.Where(e => e.Name.StartsWith(name)); } if (type != null) { listGroups = listGroups.Where(d => d.YearId == type); } if (activeGroupsName == "Активные") { listGroups = listGroups.Where(a => a.Activity != "Закрытые"); } else { listGroups = listGroups.Where(a => a.Activity == activeGroupsName); } //сортировка if (column != null) { switch (column) { case "Direction": { if (sortOrder == SortOrder.Ascending) { listGroups = listGroups.OrderBy(x => x.Direction); } else { listGroups = listGroups.OrderByDescending(x => x.Direction); } break; } case "Name": { if (sortOrder == SortOrder.Ascending) { listGroups = listGroups.OrderBy(x => x.Name); } else { listGroups = listGroups.OrderByDescending(x => x.Name); } break; } case "Year": { if (sortOrder == SortOrder.Ascending) { listGroups = listGroups.OrderBy(x => x.Year); } else { listGroups = listGroups.OrderByDescending(x => x.Year); } break; } case "StudentsF": { if (sortOrder == SortOrder.Ascending) { listGroups = listGroups.OrderBy(x => x.StudentsF); } else { listGroups = listGroups.OrderByDescending(x => x.StudentsF); } break; } } } else { listGroups = listGroups.OrderBy(f => f.Direction); } dgvListGroups.DataSource = listGroups.ToList(); ///////////////////////расчет итогов///////////////////////////// //количество групп toolStripStatusLabel2.Text = dgvListGroups.Rows.Count.ToString(); double summScheds = 0; double summPays = 0; double summDebt = 0; double summPrepayment = 0; foreach (DataGridViewRow row in dgvListGroups.Rows) { //итого начислено со скидкой summScheds += (double)row.Cells["AccrualDiscount"].Value; //итого платежей summPays += (double)row.Cells["Payment"].Value; //итого долг summDebt += ((double)row.Cells["Saldo"].Value > 0) ? (double)row.Cells["Saldo"].Value : 0; //итого аванс summPrepayment += ((double)row.Cells["Saldo"].Value < 0) ? (double)row.Cells["Saldo"].Value : 0; } if (sortOrder != SortOrder.None) { dgvListGroups.Columns[sortColumn].HeaderCell.SortGlyphDirection = (SortOrder)sortOrder; } toolStripStatusLabel4.Text = summScheds.ToString("C", CultureInfo.CurrentCulture); toolStripStatusLabel6.Text = summPays.ToString("C", CultureInfo.CurrentCulture); toolStripStatusLabel9.Text = summDebt.ToString("C", CultureInfo.CurrentCulture); toolStripStatusLabel11.Text = (-summPrepayment).ToString("C", CultureInfo.CurrentCulture); } catch (Exception ex) { var m = new System.Diagnostics.StackTrace(false).GetFrame(0).GetMethod(); string methodName = m.DeclaringType.ToString() + ";" + m.Name; CurrentSession.ReportError(methodName, ex.Message); MessageBox.Show(ex.Message, "Ошибка", MessageBoxButtons.OK, MessageBoxIcon.Error); } }
public IReadOnlyList <TModel> GetAllByFilter(Specification <TModel, bool> specification, Specification <TModel, object> orderSpecification = null, SortOrder?sortOrder = null) { if (orderSpecification == null || sortOrder == null) { return(DbContext.Set <TModel>()? .Where(specification?.ToExpression() ?? throw new InvalidOperationException())? .OrderBy("CreatedDate") .ToList() as List <TModel>); } else { return(DbContext.Set <TModel>() .Where(specification?.ToExpression() ?? throw new InvalidOperationException()) .OrderBy(orderSpecification?.ToExpression() ?? throw new InvalidOperationException()) .ToList() as List <TModel>); } }
public GridTasksSortSettings(TaskFieldsUI firstColumn, SortOrder firstColumnSortOrder, TaskFieldsUI?secondColumn, SortOrder?secondColumnOrder) { FirstColumn = firstColumn; FirstColumnSortOrder = firstColumnSortOrder; SecondColumn = secondColumn; SecondColumnSortOrder = secondColumnOrder; }
public async Task OnGetAsync(SortOrder?sort) { Sort = sort; var teamsData = await PuzzleStateHelper.GetSparseQuery(_context, this.Event, null, null) .Where(s => s.SolvedTime != null && s.Puzzle.IsPuzzle) .GroupBy(state => state.Team) .Select(g => new { Team = g.Key, SolveCount = g.Count(), Score = g.Sum(s => s.Puzzle.SolveValue), FinalMetaSolveTime = g.Where(s => s.Puzzle.IsCheatCode).Any() ? DateTime.MaxValue : (g.Where(s => s.Puzzle.IsFinalPuzzle).Select(s => s.SolvedTime).FirstOrDefault() ?? DateTime.MaxValue) }) .OrderBy(t => t.FinalMetaSolveTime).ThenByDescending(t => t.Score).ThenBy(t => t.Team.Name) .ToListAsync(); var teams = new List <TeamStats>(teamsData.Count); TeamStats prevStats = null; for (int i = 0; i < teamsData.Count; i++) { var data = teamsData[i]; var stats = new TeamStats() { Team = data.Team, SolveCount = data.SolveCount, Score = data.Score, FinalMetaSolveTime = data.FinalMetaSolveTime }; if (prevStats == null || stats.FinalMetaSolveTime != prevStats.FinalMetaSolveTime || stats.Score != prevStats.Score) { stats.Rank = i + 1; } else { stats.Rank = prevStats.Rank; } teams.Add(stats); prevStats = stats; } switch (sort) { case SortOrder.RankAscending: break; case SortOrder.RankDescending: teams.Reverse(); break; case SortOrder.NameAscending: teams.Sort((a, b) => a.Team.Name.CompareTo(b.Team.Name)); break; case SortOrder.NameDescending: teams.Sort((a, b) => - a.Team.Name.CompareTo(b.Team.Name)); break; case SortOrder.PuzzlesAscending: teams.Sort((a, b) => a.SolveCount.CompareTo(b.SolveCount)); break; case SortOrder.PuzzlesDescending: teams.Sort((a, b) => - a.SolveCount.CompareTo(b.SolveCount)); break; case SortOrder.ScoreAscending: teams.Sort((a, b) => a.Score.CompareTo(b.Score)); break; case SortOrder.ScoreDescending: teams.Sort((a, b) => - a.Score.CompareTo(b.Score)); break; case SortOrder.HintsUsedAscending: teams.Sort((a, b) => a.Score.CompareTo(b.Team.HintCoinsUsed)); break; case SortOrder.HintsUsedDescending: teams.Sort((a, b) => - a.Score.CompareTo(b.Team.HintCoinsUsed)); break; } this.Teams = teams; }
public static CustomResponse WithGridResponse(this CustomResponse customResponse, int totalMatches, int currentPage, int count, string sortBy = null, SortOrder?sortOrder = null) { if (currentPage < 1) { currentPage = 1; } count = Math.Min(count, totalMatches); var r = customResponse.With("current", currentPage) .With("rowCount", count) .With("rangeStart", (currentPage - 1) * count + 1) .With("rangeEnd", currentPage * count) .With("total", totalMatches); if (!sortBy.IsNullEmptyOrWhiteSpace()) { r.With("sortBy", sortBy); } if (sortOrder.HasValue) { r.With("sortOrder", sortOrder.Value); } return(r); }
/// <summary> /// Gets the files for folder. /// </summary> /// <param name="folderId">The folder id.</param> /// <param name="filters">The filters.</param> /// <param name="limit">The limit.</param> /// <param name="offset">The offset.</param> /// <param name="sortBy">The sort by.</param> /// <param name="sortOrder">The sort order.</param> /// <returns></returns> /// <exception cref="System.ArgumentNullException"></exception> public static string GetFilesForFolder(string folderId, List <FolderFilter> filters = null, int?limit = null, int?offset = null, SortBy?sortBy = null, SortOrder?sortOrder = null) { if (string.IsNullOrEmpty(folderId)) { throw new ArgumentNullException(folderId); } var query = GetQuery(filters, limit, offset, sortBy, sortOrder); return(string.Format("{0}/{1}{2}", folderId, SkyDriveConstants.GetFiles, query)); }
public GridIssuesSortSettings(IssueFieldsUI firstColumn, SortOrder firstColumnSortOrder, IssueFieldsUI?secondColumn, SortOrder?secondColumnOrder) { FirstColumn = firstColumn; FirstColumnSortOrder = firstColumnSortOrder; SecondColumn = secondColumn; SecondColumnSortOrder = secondColumnOrder; }
// GET: Advanced Song Search public ActionResult SongAdvancedSearchResults(string SongSearchString, string ArtistSearchString, string AlbumSearchString, int[] SelectedGenres, decimal?SongRatingDec, Operation?SelectedSongRatingOperation, SortOrder?SelectedSortOrder) { // create the list of songs with no data List <Song> SelectedSongList = new List <Song>(); foreach (var item in db.Songs) { item.SongAverage = GetSongAverage(item.SongID); } var query = from c in db.Songs select c; //code to find songs by name if (SongSearchString != null && SongSearchString != "") { query = query.Where(c => c.SongName.Contains(SongSearchString)); } //code to find songs by artist if (ArtistSearchString != null && ArtistSearchString != "") { query = query.Where(c => c.SongArtists.Any(g => g.ArtistName.Contains(ArtistSearchString))); } //code to find songs by album if (AlbumSearchString != null && AlbumSearchString != "") { query = query.Where(c => c.SongAlbums.Any(g => g.AlbumName.Contains(AlbumSearchString))); } //code to find songs by rating if (SongRatingDec != null && SelectedSongRatingOperation != null) { //if the user entered a number <1 or >5 if (SongRatingDec < 1 || SongRatingDec > 5) { ViewBag.ErrorMessage = "Please specify a number between 1.0 and 5.0 inclusive."; return(View("SongAdvancedSearch")); } Decimal AverageRatingsSearch; try { AverageRatingsSearch = Convert.ToDecimal(SongRatingDec); if (SelectedSongRatingOperation == Operation.LessThan) { query = query.Where(c => c.SongAverage < AverageRatingsSearch); } else { query = query.Where(c => c.SongAverage < AverageRatingsSearch); } } catch // will display when something is wrong { //Add error message to viewbag ViewBag.ErrorMessage = "Please specify a valid rating number"; return(View("SongAdvancedSearch")); } } //code to find songss by genre if (SelectedGenres != null) { List <Song> SongGenreList = new List <Song>(); foreach (var item in SelectedGenres) { foreach (var item2 in query.Where(c => c.SongGenres.Any(g => g.GenreID == item)).ToList()) { SongGenreList.Add(item2); } } //select disctinct item in list var distinctNames = (from d in SongGenreList select d).Distinct(); //if they selected a sort order if (SelectedSortOrder != null) { if (SelectedSortOrder == SortOrder.AscendingName) { distinctNames = distinctNames.OrderBy(d => d.SongName); } else if (SelectedSortOrder == SortOrder.DescendingName) { distinctNames = distinctNames.OrderByDescending(d => d.SongName); } else if (SelectedSortOrder == SortOrder.AscendingArtist) { distinctNames = distinctNames.OrderBy(d => d.SongArtists.First().ArtistName); } else if (SelectedSortOrder == SortOrder.DescendingArtist) { distinctNames = distinctNames.OrderByDescending(d => d.SongArtists.First().ArtistName); } else if (SelectedSortOrder == SortOrder.AscendingRating) { distinctNames = distinctNames.OrderBy(d => d.SongAverage); } else if (SelectedSortOrder == SortOrder.DescendingRating) { distinctNames = distinctNames.OrderByDescending(d => d.SongAverage); } } ViewBag.TotalCount = db.Songs.Count(); ViewBag.ResultsCount = distinctNames.Count(); return(View("SongSearchIndex", distinctNames)); } //if they selected a sort order if (SelectedSortOrder != null) { if (SelectedSortOrder == SortOrder.AscendingName) { query = query.OrderBy(d => d.SongName); } else if (SelectedSortOrder == SortOrder.DescendingName) { query = query.OrderByDescending(d => d.SongName); } else if (SelectedSortOrder == SortOrder.AscendingArtist) { query = query.OrderBy(d => d.SongArtists.First().ArtistName); } else if (SelectedSortOrder == SortOrder.DescendingArtist) { query = query.OrderByDescending(d => d.SongArtists.First().ArtistName); } else if (SelectedSortOrder == SortOrder.AscendingRating) { query = query.OrderBy(d => d.SongAverage); } else if (SelectedSortOrder == SortOrder.DescendingRating) { query = query.OrderByDescending(d => d.SongAverage); } } SelectedSongList = query.ToList(); ViewBag.TotalCount = db.Songs.Count(); ViewBag.ResultsCount = SelectedSongList.Count(); return(View("SongSearchIndex", SelectedSongList)); }
public async Task OnGetAsync(SortOrder?sort, PuzzleStateFilter?stateFilter) { this.Sort = sort; this.StateFilter = stateFilter; this.CurrentTeam = (await UserEventHelper.GetTeamForPlayer(_context, Event, LoggedInUser)); Dictionary <int, string> teamNameLookup = new Dictionary <int, string>(); // build an ID-to-name mapping to improve perf var names = await _context.Teams.Where(t => t.Event == Event) .Select(t => new { t.ID, t.Name }) .ToListAsync(); names.ForEach(t => teamNameLookup[t.ID] = t.Name); DateTime submissionEnd = Event.AnswerSubmissionEnd; // get the page data: puzzle, solve count, top three fastest var puzzlesData = await PuzzleStateHelper.GetSparseQuery(_context, this.Event, null, null) .Where(s => s.SolvedTime != null && s.Puzzle.IsPuzzle && s.SolvedTime <= submissionEnd) .GroupBy(state => state.Puzzle) .Select(g => new { Puzzle = g.Key, SolveCount = g.Count(), Fastest = g.OrderBy(s => s.SolvedTime - s.UnlockedTime).Take(3).Select(s => new { s.Team.ID, Time = s.SolvedTime - s.UnlockedTime }), IsSolvedByUserTeam = g.Where(s => s.Team == this.CurrentTeam).Any() }) .OrderByDescending(p => p.SolveCount).ThenBy(p => p.Puzzle.Name) .ToListAsync(); var unlockedData = this.CurrentTeam == null ? null : (new HashSet <int>( await PuzzleStateHelper.GetSparseQuery(_context, this.Event, null, null) .Where(state => state.Team == this.CurrentTeam && state.UnlockedTime != null) .Select(s => s.PuzzleID) .ToListAsync())); var puzzles = new List <PuzzleStats>(puzzlesData.Count); for (int i = 0; i < puzzlesData.Count; i++) { var data = puzzlesData[i]; // For players, we will hide puzzles they have not unlocked yet. if (EventRole == EventRole.play && (unlockedData == null || !unlockedData.Contains(data.Puzzle.ID))) { continue; } var stats = new PuzzleStats() { Puzzle = data.Puzzle, SolveCount = data.SolveCount, SortOrder = i, Fastest = data.Fastest.Select(f => new FastRecord() { ID = f.ID, Name = teamNameLookup[f.ID], Time = f.Time }).ToArray(), IsSolved = data.IsSolvedByUserTeam }; puzzles.Add(stats); } if (this.StateFilter == PuzzleStateFilter.Unsolved) { puzzles = puzzles.Where(stats => !stats.IsSolved).ToList(); } switch (sort ?? DefaultSort) { case SortOrder.RankAscending: puzzles.Sort((rhs, lhs) => (rhs.SortOrder - lhs.SortOrder)); break; case SortOrder.RankDescending: puzzles.Sort((rhs, lhs) => (lhs.SortOrder - rhs.SortOrder)); break; case SortOrder.CountAscending: puzzles.Sort((rhs, lhs) => (rhs.SolveCount - lhs.SolveCount)); break; case SortOrder.CountDescending: puzzles.Sort((rhs, lhs) => (lhs.SolveCount - rhs.SolveCount)); break; case SortOrder.PuzzleAscending: puzzles.Sort((rhs, lhs) => (String.Compare(rhs.Puzzle.Name, lhs.Puzzle.Name, StringComparison.OrdinalIgnoreCase))); break; case SortOrder.PuzzleDescending: puzzles.Sort((rhs, lhs) => (String.Compare(lhs.Puzzle.Name, rhs.Puzzle.Name, StringComparison.OrdinalIgnoreCase))); break; default: throw new ArgumentException($"unknown sort: {sort}"); } this.Puzzles = puzzles; }
public ActionResult Index(string SearchNum, string SearchString, int?daysBack, DateTime?startDate, DateTime?endDate, int?price, decimal?priceFloor, decimal?priceCap, TransactionType?SelectedType, TransactionStatus?ApprovalStatus, SortOrder?SelectedSortOrder) { if ((SearchNum == null || SearchNum == "") && (SearchString == null || SearchNum == "") && (daysBack == null) && (startDate == null) && (endDate == null) && (price == null) && (priceFloor == null) && (priceCap == null) && (SelectedType == null)) { //ViewBag.NumberAllTransactions = db.Transactions.ToList().Count(); //ViewBag.NumberSelectedTransactions = db.Transactions.ToList().Count(); var queryA = from t in db.Transactions select t; queryA = queryA.Where(t => t.ApprovalStatus == TransactionStatus.Approved); List <Transaction> ApprovedTransactions = queryA.ToList(); ViewBag.NumberAllTransactions = db.Transactions.ToList().Count(); ViewBag.NumberSelectedTransactions = ApprovedTransactions.Count; return(View(ApprovedTransactions)); //return View(db.Transactions); } var query = from t in db.Transactions select t; // Search by number if (SearchNum == null || SearchNum == "") { query = query; } else { query = query.Where(t => t.TransactionID.ToString().Contains(SearchNum)); } // Search by name if (SearchString == null || SearchString == "") { query = query; } else { query = query.Where(t => t.TransactionDescription.Contains(SearchString)); } // Filter by date if (daysBack == 0) { query = query; } else { if (daysBack == 696969) { query = query.Where(t => t.TransactionDate >= startDate && t.TransactionDate <= endDate); } else { var oldestDate = (DateTime.Today).AddDays(Convert.ToDouble(daysBack) * -1); query = query.Where(t => t.TransactionDate >= oldestDate); } } // Filter by price if (price == 707070) { query = query; } else { if (price == 696969) { query = query.Where(t => t.TransactionAmount >= priceFloor && t.TransactionAmount <= priceCap); } else { if (price == 300) { query = query.Where(t => t.TransactionAmount >= price); } else { var rangeCap = price + 100; query = query.Where(t => t.TransactionAmount >= price && t.TransactionAmount <= rangeCap); } } } // Filter by type if (SelectedType == null) { query = query; } else { query = query.Where(t => t.TypeOfTransaction == SelectedType); } if (SelectedSortOrder == SortOrder.AscTransactionNumber) { query = query.OrderBy(t => t.TransactionID); } if (SelectedSortOrder == SortOrder.DescTransactionNumber) { query = query.OrderByDescending(t => t.TransactionID); } if (SelectedSortOrder == SortOrder.AscTransactionType) { query = query.OrderBy(t => t.TypeOfTransaction.ToString()); } if (SelectedSortOrder == SortOrder.DescTransactionType) { query = query.OrderByDescending(t => t.TypeOfTransaction.ToString()); } if (SelectedSortOrder == SortOrder.AscTransactionDescription) { query = query.OrderBy(t => t.TransactionDescription); } if (SelectedSortOrder == SortOrder.DescTransactionDescription) { query = query.OrderByDescending(t => t.TransactionDescription); } if (SelectedSortOrder == SortOrder.AscTransactionAmount) { query = query.OrderBy(t => t.TransactionAmount); } if (SelectedSortOrder == SortOrder.DescTransactionAmount) { query = query.OrderByDescending(t => t.TransactionAmount); } if (SelectedSortOrder == SortOrder.AscTransactionDate) { query = query.OrderBy(t => t.TransactionDate); } if (SelectedSortOrder == SortOrder.DescTransactionDate) { query = query.OrderByDescending(t => t.TransactionDate); } List <Transaction> SelectedTransactions = query.ToList(); ViewBag.NumberAllTransactions = db.Transactions.ToList().Count(); ViewBag.NumberSelectedTransactions = SelectedTransactions.Count; return(View(SelectedTransactions)); }
public async Task <IActionResult> OnGetAsync(int?puzzleId, int?teamId, SortOrder?sort) { Sort = sort; IQueryable <Submission> submissionsQ = null; if (puzzleId == null) { if (EventRole == EventRole.admin) { if (teamId == null) { submissionsQ = _context.Submissions.Where((s) => s.Puzzle.Event == Event); } else { submissionsQ = _context.Submissions.Where((s) => s.Team.ID == teamId); } } else { if (teamId == null) { submissionsQ = UserEventHelper.GetPuzzlesForAuthorAndEvent(_context, Event, LoggedInUser) .SelectMany((p) => p.Submissions); } else { submissionsQ = UserEventHelper.GetPuzzlesForAuthorAndEvent(_context, Event, LoggedInUser) .SelectMany((p) => p.Submissions.Where((s) => s.Team.ID == teamId)); } } } else { Puzzle = await _context.Puzzles.Where(m => m.ID == puzzleId).FirstOrDefaultAsync(); if (EventRole == EventRole.author && !await UserEventHelper.IsAuthorOfPuzzle(_context, Puzzle, LoggedInUser)) { return(Forbid()); } if (teamId == null) { submissionsQ = _context.Submissions.Where((s) => s.Puzzle != null && s.Puzzle.ID == puzzleId); } else { submissionsQ = _context.Submissions.Where((s) => s.Puzzle != null && s.Puzzle.ID == puzzleId && s.Team.ID == teamId); } } IQueryable <SubmissionView> submissionViewQ = submissionsQ .Select((s) => new SubmissionView { SubmitterName = s.Submitter.Name, PuzzleID = s.Puzzle.ID, PuzzleName = s.Puzzle.Name, TeamID = s.Team.ID, TeamName = s.Team.Name, SubmissionText = s.SubmissionText, ResponseText = s.Response == null ? null : s.Response.ResponseText, TimeSubmitted = s.TimeSubmitted }); if (teamId != null) { Team = await _context.Teams.Where(m => m.ID == teamId).FirstOrDefaultAsync(); } switch (sort ?? DefaultSort) { case SortOrder.PlayerAscending: submissionViewQ.OrderBy(submission => submission.SubmitterName); break; case SortOrder.PlayerDescending: submissionViewQ.OrderByDescending(submission => submission.SubmitterName); break; case SortOrder.TeamAscending: submissionViewQ.OrderBy(submission => submission.TeamName); break; case SortOrder.TeamDescending: submissionViewQ.OrderByDescending(submission => submission.TeamName); break; case SortOrder.PuzzleAscending: submissionViewQ.OrderBy(submission => submission.PuzzleName); break; case SortOrder.PuzzleDescending: submissionViewQ.OrderByDescending(submission => submission.PuzzleName); break; case SortOrder.ResponseAscending: submissionViewQ.OrderBy(submission => submission.ResponseText); break; case SortOrder.ResponseDescending: submissionViewQ.OrderByDescending(submission => submission.ResponseText); break; case SortOrder.SubmissionAscending: submissionViewQ.OrderBy(submission => submission.SubmissionText); break; case SortOrder.SubmissionDescending: submissionViewQ.OrderByDescending(submission => submission.SubmissionText); break; case SortOrder.TimeAscending: submissionViewQ.OrderBy(submission => submission.TimeSubmitted); break; case SortOrder.TimeDescending: submissionViewQ.OrderByDescending(submission => submission.TimeSubmitted); break; } Submissions = await submissionViewQ.ToListAsync(); return(Page()); }
private void Filter(int?directionId, string name, int?typeId, int?teacherId, string activeGroupsName, string column, SortOrder?sortOrder) { try { var listGroups = from groups in db.Groups join courses in db.Courses on groups.CourseId equals courses.Id join directions in db.Directions on courses.DirectionId equals directions.Id join teachers in db.Workers on groups.TeacherId equals teachers.Id into outerTeacher from teachers in outerTeacher.DefaultIfEmpty() join activities in db.ActivityGroups on groups.ActivityId equals activities.Id join classes in db.Classes on groups.ClassId equals classes.Id into outerClass from classes in outerClass.DefaultIfEmpty() join branches in db.Housings on classes.HousingId equals branches.Id into outerBranch from branches in outerBranch.DefaultIfEmpty() join years in db.Years on groups.YearId equals years.Id into outer from years in outer.DefaultIfEmpty() select new ListGroups { GroupId = groups.Id, DirectionId = directions.Id, Direction = directions.Name, TeacherId = teachers.Id, ActivityId = activities.Id, YearId = years.Id, Name = groups.Name, Branch = branches.Name, Class = classes.Name, Days = groups.Days, Begin = groups.Begin, DurationLesson = groups.DurationLesson, Year = years.Name, Teacher = teachers.Lastname + " " + teachers.Firstname.Substring(0, 1) + "." + teachers.Middlename.Substring(0, 1) + ".", TwoTeachers = groups.TwoTeachers, Students = db.Enrollments.Where(a => a.GroupId == groups.Id && a.DateExclusion == null).Count(), Note = groups.Note, Activity = activities.Name }; if (directionId != null) { listGroups = listGroups.Where(d => d.DirectionId == directionId); } if (teacherId != null) { listGroups = listGroups.Where(d => d.TeacherId == teacherId); } if (name != null && name != "") { listGroups = listGroups.Where(e => e.Name.StartsWith(name)); } if (typeId != null) { listGroups = listGroups.Where(d => d.YearId == typeId); } if (activeGroupsName == "Активные") { listGroups = listGroups.Where(a => a.Activity != "Закрытые"); } else { listGroups = listGroups.Where(a => a.Activity == activeGroupsName); } //фильтрация по праву доступа к группам if (!CurrentSession.CurrentUser.AllAccessGroups) { var listOpenGroups = db.AccessGroups.Where(a => a.WorkerId == CurrentSession.CurrentUser.Id).Select(a => a.GroupId).ToList(); listGroups = listGroups.Where(a => listOpenGroups.Contains(a.GroupId)); } //сортировка if (column != null) { switch (column) { case "Direction": { if (sortOrder == SortOrder.Ascending) { listGroups = listGroups.OrderBy(x => x.Direction); } else { listGroups = listGroups.OrderByDescending(x => x.Direction); } break; } case "Name": { if (sortOrder == SortOrder.Ascending) { listGroups = listGroups.OrderBy(x => x.Name); } else { listGroups = listGroups.OrderByDescending(x => x.Name); } break; } case "Days": { if (sortOrder == SortOrder.Ascending) { listGroups = listGroups.OrderBy(x => x.Days); } else { listGroups = listGroups.OrderByDescending(x => x.Days); } break; } case "DurationLesson": { if (sortOrder == SortOrder.Ascending) { listGroups = listGroups.OrderBy(x => x.DurationLesson); } else { listGroups = listGroups.OrderByDescending(x => x.DurationLesson); } break; } case "Year": { if (sortOrder == SortOrder.Ascending) { listGroups = listGroups.OrderBy(x => x.Year); } else { listGroups = listGroups.OrderByDescending(x => x.Year); } break; } case "Teacher": { if (sortOrder == SortOrder.Ascending) { listGroups = listGroups.OrderBy(x => x.Teacher); } else { listGroups = listGroups.OrderByDescending(x => x.Teacher); } break; } case "TwoTeachers": { if (sortOrder == SortOrder.Ascending) { listGroups = listGroups.OrderBy(x => x.TwoTeachers); } else { listGroups = listGroups.OrderByDescending(x => x.TwoTeachers); } break; } case "Note": { if (sortOrder == SortOrder.Ascending) { listGroups = listGroups.OrderBy(x => x.Note); } else { listGroups = listGroups.OrderByDescending(x => x.Note); } break; } case "Students": { if (sortOrder == SortOrder.Ascending) { listGroups = listGroups.OrderBy(x => x.Students); } else { listGroups = listGroups.OrderByDescending(x => x.Students); } break; } } } else { listGroups = listGroups.OrderBy(f => f.Direction); } dgvListGroups.DataSource = listGroups.ToList(); if (sortOrder != SortOrder.None) { dgvListGroups.Columns[sortColumn].HeaderCell.SortGlyphDirection = (SortOrder)sortOrder; } } catch (Exception ex) { var m = new System.Diagnostics.StackTrace(false).GetFrame(0).GetMethod(); string methodName = m.DeclaringType.ToString() + ";" + m.Name; CurrentSession.ReportError(methodName, ex.Message); MessageBox.Show(ex.Message, "Ошибка", MessageBoxButtons.OK, MessageBoxIcon.Error); } }
public async Task ProperlyParsesOrderBy(string queryString, SortOrder?expected) { await TestOrderBy(queryString, expected); }
public static T Sort <T>(this T query, Field field, SortOrder?order = null) where T : IRepositoryQuery { return(query.AddCollectionOptionValue <T, IFieldSort>(SortsKey, new SortField { Field = field, Order = order })); }
/// <summary> /// <param>If set to asc or desc, the column will be sorted in that direction on first </param> /// <param>sort.Subsequent sorts of the column will toggle as usual (default: null)</param> /// </summary> /// <param name="firstSortOrder">First sort order</param> public Column setFirstSortOrder(SortOrder firstSortOrder) { this._firstSortOrder = firstSortOrder; return(this); }
/// <summary> /// <para>The initial sorting order when we use datatypes xml or json (data returned from server).</para> /// <para>This parameter is added to the url. Two possible values - asc or desc. (default: asc)</para> /// </summary> /// <param name="sortOrder">Sortorder</param> public jqGrid setSortOrder(SortOrder sortOrder) { this._sortOrder = sortOrder; return this; }
public static Sql OrderByOptional(this Sql sql, string column, SortOrder?order) { return(order.HasValue ? sql.OrderBy($"{column} {order}") : sql); }
/// <summary> /// If set to asc or desc, the column will be sorted in that direction on first /// sort.Subsequent sorts of the column will toggle as usual (default: null) /// </summary> /// <param name="firstSortOrder">First sort order</param> public Column SetFirstSortOrder(SortOrder firstSortOrder) { this.firstSortOrder = firstSortOrder; return this; }
public IList <WebRecordingBasic> GetRecordingsByRange(int start, int end, SortField?sort = SortField.Name, SortOrder?order = SortOrder.Asc) { return(Recording.ListAll().Select(rec => rec.ToWebRecording()).SortRecordingList(sort, order).TakeRange(start, end).ToList()); }