LINQ QueryResults Example: Putting it All Together

namespace Tutorial {
    using System;
    using System.Collections.Generic;
    using System.Collections.Specialized;
    using System.Linq;
    using System.Web;
    using System.Web.UI;
    using System.Web.UI.WebControls;
    using Coveo.Framework.SearchService;
    using Coveo.SearchProvider.Linq;
    using Coveo.SearchProvider.LinqBase;
    using Sitecore.ContentSearch;
    using Sitecore.ContentSearch.Linq;
    using Sitecore.ContentSearch.SearchTypes;
    public partial class LinqBasedPageExample : Page {
        protected void Page_Load(object sender, EventArgs e) {
            SearchModel searchModel = new SearchModel();
            if (Page.IsPostBack) {
                MapControlsToModel(searchModel);
                Render(searchModel);
            }
        }
        private void MapControlsToModel(SearchModel model) {
            model.Query = Querybox.Text;
            model.NbResultsPerPage = int.Parse(NbResultsPerPage.Text);
            if(!String.IsNullOrEmpty(PageNb.SelectedValue)) {
                model.Page = int.Parse(PageNb.SelectedValue);
            }
            model.SortDescending = SortDescending.Checked;
            model.SortType = SortList.SelectedValue;
            IList<FacetModel> facets = new List<FacetModel>();
            foreach(RepeaterItem facetItem in FacetsRepeater.Items){
                Label fieldNameLabel = facetItem.FindControl("FacetFieldName") as Label;
                Repeater valuesRepeater = facetItem.FindControl("FacetValues") as Repeater;
                foreach(RepeaterItem facetValueItem in valuesRepeater.Items){
                    CheckBox box = facetValueItem.FindControl("ValueCheckbox") as CheckBox;
                    if(box.Checked){
                        facets.Add(new FacetModel {
                            FieldName = fieldNameLabel.Text,
                            FieldValue = box.Text
                        });
                    }
                }
            }
            model.Facets = facets;
        }
        private void Render(SearchModel model) {
            if(!String.IsNullOrEmpty(model.Query)) {
                try{
                    ClearResults();
                    QueryResults<SearchResult> results = ExecuteQuery(model);
                    if(results.TotalCount != 0) {
                        RenderWithResults(model, results);
                    } else {
                        RenderWithoutResults(model, results);
                    }
                    RenderCommon(model, results);
                }catch(Exception ex){
                    RenderException(model, ex);
                }
            }
        }
        private void ClearResults() {
            LSTResults.DataSource = "";
            LSTResults.DataBind();
        }
        private void RenderWithResults(SearchModel model,
                                       QueryResults<SearchResult> results) {
            LSTResults.DataSource = results.Results;
            LSTResults.DataBind();
            int numberOfPages = GetNumberOfPages(results.TotalCount, model.NbResultsPerPage);
            for(int i = 0; i < numberOfPages; i++) {
                PageNb.Items.Add(new ListItem(i.ToString(), i.ToString()));
            }
            if(results.GroupByResults.Count > 0) {
                FacetsRepeater.DataSource = results.GroupByResults;
                FacetsRepeater.DataBind();
            }
            NoResultsSection.Visible = false;
            ResultsSection.Visible = true;
        }
        private int GetNumberOfPages(double totalCount, int nbResultsPerPage) {
            return (int)Math.Ceiling(totalCount / nbResultsPerPage);
        }
        private void RenderWithoutResults(SearchModel model,
                                          QueryResults<SearchResult> results) {
            NoResultsLabel.Text = "No results for " + model.Query;
            NoResultsSection.Visible = true;
            ResultsSection.Visible = false;
        }
        private void RenderCommon(SearchModel model,
                                  QueryResults<SearchResult> results){
            if(results.QueryCorrections.Count > 0) {
                DidYouMeanRepeater.DataSource = results.QueryCorrections;
                DidYouMeanRepeater.DataBind();
                DidYouMeanSection.Visible = true;
            }
            CurrentExpressionLabel.Text = results.Debug.BasicExpression;
        }
        private void RenderException(SearchModel model,
                                     Exception e){
            ResultsSection.Visible = false;
            QueryErrorSection.Visible = true;
            QueryErrorLabel.Text = "Exception thrown while querying: " + e.Message.ToString();
        }
        private QueryResults<SearchResult> ExecuteQuery(SearchModel model) {
            QueryResults<SearchResult> results;
            ISearchIndex index = ContentSearchManager.GetIndex("Coveo_web_index");
            using (var context = index.CreateSearchContext()) {
                  IQueryable<SearchResult> query = context.GetQueryable<SearchResult>()
                                                              .CoveoOr(model.Query)
                                                              .Skip(model.NbResultsPerPage * model.Page)
                                                              .Take(model.NbResultsPerPage)
                                                              .FacetOn(item => item.TemplateName)
                                                              .SortBy(model.SortType, model.SortDescending);
                  foreach(FacetModel facet in model.Facets){
                      query = query.CoveoWhere(facet.Expression);
                  }
                  results = query.GetCoveoQueryResults();
            }
            return results;
        }
    }
    public class SearchResult {
        public DateTime Updated { get; set; }
        public DateTime Date { get; set; }
        public string Title { get; set; }
        public string PrintableURI { get; set; }
        [IndexField("_templatename")]
        public string TemplateName { get; set; }
    }
    public class SearchModel {
        private const string QUERY_PARAMETER_NAME = "query";
        private const string NB_RESULTS_PER_PAGE_PARAMETER_NAME = "nbResultsPerPage";
        private const string PAGE_PARAMETER_NAME = "page";
        private const string FACETS_PARAMETER_NAME = "facets";
        private const string IS_DESCENDING_PARAMETER_NAME = "descending";
        private const string SORT_PARAMETER_NAME = "sort";
        public const int DEFAULT_NB_RESULTS_PER_PAGE = 20;
        public string Query { get; set; }
        public int NbResultsPerPage { get; set; }
        public int Page { get; set; }
        public IList<FacetModel> Facets { get; set; }
        public string SortType { get; set; }
        public bool SortDescending { get; set; }
        public SearchModel() {
            Query = "";
            NbResultsPerPage = DEFAULT_NB_RESULTS_PER_PAGE;
            Page = 0;
            Facets = new List<FacetModel>();
            SortType = SortTypes.Relevancy;
            SortDescending = true;
        }
    }
    public class FacetModel {
        public string FieldName { get; set; }
        public string FieldValue { get; set; }
        public string Expression {
            get {
                return "@" + FieldName + "==\"" + FieldValue + "\"";
            }
        }
    }
    public static class SortTypes {
        public const string Date = "date";
        public const string Relevancy = "relevancy";
    }
    public static class QueryableSearchResultsExtensions {
        public static IQueryable<SearchResult> SortBy(this IQueryable<SearchResult> query,
                                                      string sortType,
                                                      bool isDescending) {
            switch(sortType){
                case SortTypes.Date:
                    return isDescending ? query.OrderByDescending(item => item.Updated)
                                        : query.OrderBy(item => item.Updated);
                case SortTypes.Relevancy:
                    return query;
                default:
                    throw new NotSupportedException("This sort type is not supported.");
            }
        }
    }
}