protected override IQueryable <IndexViewModel> ApplySorting(
                IQueryable <IndexViewModel> chainQuery, ISortParam sortParam)
            {
                UserSortStateModel.State sortState;
                Enum.TryParse(sortParam.SortKey, true, out sortState);

                switch (sortState)
                {
                case UserSortStateModel.State.NicknameDesc:
                    chainQuery = chainQuery.OrderByDescending(x => x.UserName);
                    break;

                case UserSortStateModel.State.RegDate:
                    chainQuery = chainQuery.OrderBy(x => x.RegisteredOnUtc);
                    break;

                case UserSortStateModel.State.RegDateDesc:
                    chainQuery = chainQuery.OrderByDescending(x => x.RegisteredOnUtc);
                    break;

                case UserSortStateModel.State.LastLoginDate:
                    chainQuery = chainQuery.OrderBy(x => x.LastLoginOnUtc);
                    break;

                case UserSortStateModel.State.LastLoginDateDesc:
                    chainQuery = chainQuery.OrderByDescending(x => x.LastLoginOnUtc);
                    break;

                default:
                    chainQuery = chainQuery.OrderBy(x => x.UserName);
                    break;
                }

                return(chainQuery);
            }
            protected override IQueryable <IndexViewModel> ApplySorting(IQueryable <IndexViewModel> chainQuery,
                                                                        ISortParam sortParam)
            {
                IndexSortStateModel.State sortState;
                Enum.TryParse(sortParam.SortKey, true, out sortState);

                switch (sortState)
                {
                case IndexSortStateModel.State.CategoryDesc:
                    chainQuery = chainQuery.OrderByDescending(x => x.CategoryName);
                    break;

                case IndexSortStateModel.State.CourseCount:
                    chainQuery = chainQuery.OrderBy(x => x.CourseCount);
                    break;

                case IndexSortStateModel.State.CourseCountDesc:
                    chainQuery = chainQuery.OrderByDescending(x => x.CourseCount);
                    break;

                default:
                    chainQuery = chainQuery.OrderBy(x => x.CategoryName);
                    break;
                }

                return(chainQuery);
            }
            protected override IQueryable <IndexViewModel> ApplySorting(IQueryable <IndexViewModel> chainQuery,
                                                                        ISortParam sortParam)
            {
                UpdateEventSortModel.State sortState;
                Enum.TryParse(sortParam.SortKey, true, out sortState);

                switch (sortState)
                {
                case UpdateEventSortModel.State.TrainingProvider:
                    chainQuery = chainQuery.OrderBy(x => x.TrainingProviderName).ThenByDescending(x => x.Id);
                    break;

                case UpdateEventSortModel.State.TrainingProviderDesc:
                    chainQuery = chainQuery.OrderByDescending(x => x.TrainingProviderName).ThenByDescending(x => x.Id);
                    break;

                case UpdateEventSortModel.State.StartDate:
                    chainQuery = chainQuery.OrderBy(x => x.StartedOn);
                    break;

                case UpdateEventSortModel.State.EndDate:
                    chainQuery = chainQuery.OrderBy(x => x.EndedOn);
                    break;

                case UpdateEventSortModel.State.EndDateDesc:
                    chainQuery = chainQuery.OrderByDescending(x => x.EndedOn);
                    break;

                case UpdateEventSortModel.State.Duration:
                    chainQuery = chainQuery.OrderBy(x => SqlFunctions.DateDiff("ss", x.StartedOn, x.EndedOn));
                    break;

                case UpdateEventSortModel.State.DurationDesc:
                    chainQuery = chainQuery.OrderByDescending(x => SqlFunctions.DateDiff("ss", x.StartedOn, x.EndedOn));
                    break;

                default:
                    chainQuery = chainQuery.OrderByDescending(x => x.StartedOn);
                    break;
                }

                return(chainQuery);
            }
 protected abstract IQueryable <TModel> ApplySorting(IQueryable <TModel> chainQuery, ISortParam sortParam);