Example #1
0
 /// <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;
 }
Example #2
0
 /// <inheritdoc cref="ISort.Order" />
 public virtual TDescriptor Order(SortOrder?order) => Assign(order, (a, v) => a.Order = v);
Example #3
0
        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);
        }
Example #5
0
 /// <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);
 }
Example #6
0
        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);
            }
        }
Example #7
0
        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;
        }
Example #8
0
 public Grid SetDefaultSorting(string sortField, SortOrder sortOrder)
 {
     _sortField = sortField;
     _sortOrder = sortOrder;
     return(this);
 }
Example #9
0
        /// <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);
 }
Example #11
0
 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));
 }
Example #12
0
        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));
        }
Example #14
0
 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>);
         }
     }
 }
Example #15
0
 /// <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;
 }
Example #16
0
        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);
            }
        }
Example #17
0
 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>);
     }
 }
Example #18
0
 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;
        }
Example #20
0
        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);
        }
Example #21
0
        /// <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));
        }
Example #22
0
 public GridIssuesSortSettings(IssueFieldsUI firstColumn, SortOrder firstColumnSortOrder, IssueFieldsUI?secondColumn, SortOrder?secondColumnOrder)
 {
     FirstColumn           = firstColumn;
     FirstColumnSortOrder  = firstColumnSortOrder;
     SecondColumn          = secondColumn;
     SecondColumnSortOrder = secondColumnOrder;
 }
Example #23
0
        // 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));
        }
Example #24
0
        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());
        }
Example #27
0
        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);
 }
Example #29
0
 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
     }));
 }
Example #30
0
 /// <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);
 }
Example #31
0
 /// <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;
 }
Example #32
0
 public static Sql OrderByOptional(this Sql sql, string column, SortOrder?order)
 {
     return(order.HasValue ? sql.OrderBy($"{column} {order}") : sql);
 }
Example #33
0
 /// <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;
 }
Example #34
0
 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());
 }