protected ContestQueryParameter CreateContestQueryParameter()
        {
            ContestQueryParameter query = new ContestQueryParameter();

            if (!string.IsNullOrEmpty(Request.QueryString["title"]))
            {
                query.Title        = Request.QueryString["title"];
                query.QueryByTitle = true;
            }
            if (!string.IsNullOrEmpty(Request.QueryString["author"]))
            {
                query.Creator        = Request.QueryString["author"];
                query.QueryByCreator = true;
            }
            if (!string.IsNullOrEmpty(Request.QueryString["status"]))
            {
                try
                {
                    query.Status        = ContestStatusConvert.ConvertFromString(Request.QueryString["status"]);
                    query.QueryByStatus = true;
                }
                catch (ArgumentException)
                { }
            }

            return(query);
        }
        public ActionResult ContestList()
        {
            // 获取查询参数。
            ContestQueryParameter query = CreateContestQueryParameter();

            int page = 1;

            if (!string.IsNullOrEmpty(Request.QueryString["page"]))
            {
                if (!int.TryParse(Request.QueryString["page"], out page))
                {
                    page = 1;
                }
            }

            query.EnablePagedQuery = true;
            query.PageQuery        = new PageQueryParameter(page, ContestListItemsPerPage);

            // 执行分页查询。
            IEnumerable <ContestHandle> queryResult = ContestManager.Default.QueryContests(query);

            List <ContestBriefModel> contests = new List <ContestBriefModel>();

            foreach (ContestHandle handle in queryResult)
            {
                contests.Add(ContestBriefModel.FromContestHandle(handle));
            }

            return(QueryResult(contests));
        }
        public ActionResult ContestListPages()
        {
            ContestQueryParameter query = CreateContestQueryParameter();

            query.EnablePagedQuery = true;
            query.PageQuery        = new PageQueryParameter(1, ContestListItemsPerPage);

            return(QueryResult(ContestManager.Default.QueryPages(query)));
        }
        /// <summary>
        /// 使用指定的查询参数计算满足条件的数据条目一共能填充多少页面。
        /// </summary>
        /// <param name="query">查询参数。</param>
        /// <returns>满足条件的数据条目能填充多少页面。</returns>
        /// <exception cref="ArgumentNullException"/>
        /// <exception cref="ArgumentException"/>
        /// <exception cref="ArgumentOutOfRangeException"/>
        public int QueryPages(ContestQueryParameter query)
        {
            if (query == null)
            {
                throw new ArgumentNullException(nameof(query));
            }
            if (!query.EnablePagedQuery)
            {
                throw new ArgumentException("给定的查询参数未启用分页。");
            }
            if (query.PageQuery.ItemsPerPage <= 0)
            {
                throw new ArgumentOutOfRangeException(nameof(query.PageQuery.ItemsPerPage));
            }

            return(m_factory.WithContext(context =>
            {
                IQueryable <ContestEntity> set = DoQuery(context, query);
                return set.GetPages(query.PageQuery.ItemsPerPage);
            }));
        }
        /// <summary>
        /// 使用给定的查询参数查询比赛句柄。
        /// </summary>
        /// <param name="query">封装查询参数的对象。</param>
        /// <returns>一个查询结果对象,其中包含了所有查询到的比赛句柄。</returns>
        /// <exception cref="ArgumentNullException"/>
        /// <exception cref="ArgumentException"/>
        public ReadOnlyCollection <ContestHandle> QueryContests(ContestQueryParameter query)
        {
            if (query == null)
            {
                throw new ArgumentNullException(nameof(query));
            }
            if (query.QueryByTitle && query.Title == null)
            {
                throw new ArgumentNullException(nameof(query.Title));
            }
            if (query.QueryByCreator && query.Creator == null)
            {
                throw new ArgumentNullException(nameof(query.Creator));
            }

            return(m_factory.WithContext(context =>
            {
                IQueryable <ContestEntity> set = DoQuery(context, query);

                // 对数据实体对象进行排序以准备执行分页操作。
                set = set.OrderByDescending(entity => entity.CreationTime);

                if (query.EnablePagedQuery)
                {
                    // 执行分页。
                    set = set.Page(query.PageQuery);
                }

                List <ContestHandle> handles = new List <ContestHandle>();
                foreach (ContestEntity ent in set)
                {
                    handles.Add(ContestHandle.FromContestEntity(ent));
                }

                return new ReadOnlyCollection <ContestHandle>(handles);
            }));
        }
        private static IQueryable <ContestEntity> DoQuery(ContestDataContext context, ContestQueryParameter query)
        {
            IQueryable <ContestEntity> set = context.QueryAllContests();

            if (query.QueryByTitle)
            {
                set = ContestDataContext.QueryContestsByTitle(set, query.Title);
            }
            if (query.QueryByCreator)
            {
                set = ContestDataContext.QueryContestsByCreator(set, query.Creator);
            }
            if (query.QueryByStatus)
            {
                switch (query.Status)
                {
                case ContestStatus.Pending:
                    set = ContestDataContext.QueryUnstartedContests(set);
                    break;

                case ContestStatus.Running:
                    set = ContestDataContext.QueryRunningContests(set);
                    break;

                case ContestStatus.Ended:
                    set = ContestDataContext.QueryEndedContests(set);
                    break;

                default:
                    throw new ArgumentException(nameof(query.Status));
                }
            }

            return(set);
        }