/* Creates the grid data */
        public ActionResult List(SearchParameter searchP, SearchModel searchModel)
        {            
            var model = _stores.AsQueryable();

            GridData data = model.ToGridData(searchModel, new[] { "Id", "Name", "Address" });
            return Json(data, JsonRequestBehavior.AllowGet);
        }

 public void TestSearchEmpty()
 {
     SearchModel<Status> model = new SearchModel<Status>();
     SearchValidationResult res = model.IsValidSearchCombination();
     Assert.False(res.IsValid);
     Assert.AreEqual(StringResource.NO_VALUES_TO_SEARCH, res.Description);
 }

        public void TestCombineSearch()
        {
            // create mock of MovieRepository and construct SearchHelper with it
              Mock<MovieRepository> repository = new Mock<MovieRepository>();
              repository.Setup(x => x.Select<MovieModel>()).Returns(movies.AsQueryable());
              SearchHelper searcher = new SearchHelper(repository.Object);

              // test cases

              //1
              SearchModel search1 = new SearchModel
              {
            MovieName = new SearchOption<string>(),
            Genre = new SearchOption<Genre>(),
            ActorLastName = new SearchOption<string>(),
              };
              List<MovieModel> result1 = searcher.Search(search1);
              Assert.IsTrue(result1.Count == 3);
              Assert.IsTrue(result1.Where(x => x.Name == movies[0].Name).Any());
              Assert.IsTrue(result1.Where(x => x.Name == movies[1].Name).Any());
              Assert.IsTrue(result1.Where(x => x.Name == movies[2].Name).Any());

              //2
              SearchModel search2 = new SearchModel
              {
            MovieName = new SearchOption<string>(),
            Genre = new SearchOption<Genre> { Value = Genre.Drammatic, IsCritical = true },
            ActorLastName = new SearchOption<string> { Value = "Стоун", IsCritical = true },
              };
              List<MovieModel> result2 = searcher.Search(search2);
              Assert.IsTrue(result2.Count == 1);
              Assert.IsTrue(result2.Where(x => x.Name == movies[1].Name).Any());
        }

        public ActionResult Search(SearchModel model)
        {
            ITwitterClient twitterClient = new TwitterClient();
            var tweetRepository = new TweetPageRepository();
            var cachedPage = tweetRepository.GetPageBySearchString(model.HashtagToSearchFor, model.PageToRetrieve);
            if (cachedPage != null)
            {
                return PartialView(cachedPage.ToModel(model.PageToRetrieve, PAGE_SIZE, model.HashtagToSearchFor));
            }

            int twitterPage = (int)Math.Ceiling(model.PageToRetrieve / (float)PAGE_SIZE);

            var searchResults = twitterClient.SearchByHashtag(model.HashtagToSearchFor, CACHE_SIZE, twitterPage);
            int pageCount = (int)Math.Ceiling(searchResults.Count()/(decimal)PAGE_SIZE);
            int cachePageRangeStart = ((twitterPage - 1) * PAGE_SIZE) + 1;

            var searchResultPages = Enumerable.Range(0, pageCount)
                    .Select(pageNo => searchResults.Skip(pageNo * PAGE_SIZE).Take(PAGE_SIZE))
                    .Select((page, pageNo) => page.ToRepositoryContract(cachePageRangeStart + pageNo, PAGE_SIZE, model.HashtagToSearchFor));

            tweetRepository.ReplacePages(searchResultPages);

            var currentPageResult = searchResultPages.FirstOrDefault(page => page.Page == model.PageToRetrieve);
            return PartialView(currentPageResult.ToModel(model.PageToRetrieve, PAGE_SIZE, model.HashtagToSearchFor));
        }

        public SearchModule () 
        {
            Get ["/search"] = parameters => {
                SearchModel model = new SearchModel();
                model.Planeswalker = ((Planeswalker)this.Context.CurrentUser);
                model.ActiveMenu = "search";

                return View["Search", model];
            };

            Post ["/search"] = parameters => {
                SearchModel model = this.Bind<SearchModel>();
                model.Planeswalker = ((Planeswalker)this.Context.CurrentUser);
                UserCard [] walkerCards = null;

                try
                {
                    Card[] cards = magicdb.Search(model.Term);
                    model.ActiveMenu = "search";

                    cards = cards
                        .AsEnumerable()
                        .OrderBy(x => x.Name)
                        .ThenByDescending(x => x.ReleasedAt).ToArray();

                    if(model.Planeswalker != null)
                    {
                        int [] cardIds = cards.AsEnumerable().Select(c => c.Id).ToArray();
                        walkerCards = repository.GetUserCards(model.Planeswalker.Id,cardIds);
                    }

                    foreach(var c in cards)
                    {
                        CardInfo cardInfo = new CardInfo();

                        if(walkerCards != null && walkerCards.Length > 0)
                        {
                            cardInfo.Amount = walkerCards.AsEnumerable()
                                .Where(info => info.MultiverseId == c.Id)
                                .Select(info => info.Amount).FirstOrDefault();

                        }
                        else
                        {
                            cardInfo.Amount = 0;
                        }

                        cardInfo.Card = c;
                        model.Cards.Add(cardInfo);
                    }
                }
                catch(Exception e)
                {
                    model.Errors.Add(e.Message);
                }
               
                return View["Search", model];
            };
        }

        public ActionResult ChildList(int productId, SearchModel searchModel)
        {
            StoreRepository rep = new StoreRepository();
            List<Store> stores = rep.GetByProductId(productId);

            var model = stores.AsQueryable();
            return Json(model.ToGridData(searchModel, new[] { "Id", "Name", "Address" }), JsonRequestBehavior.AllowGet);
        }

 public void SetSearch(SearchModel searchRouter)
 {
     base.SetSearch(searchRouter);
     this.SearchBytitleCh = searchRouter.SearchBytitleCh;
     this.SearchBytitleEng = searchRouter.SearchBytitleEng;
     this.SearchByteacherName = searchRouter.SearchByteacherName;
     this.SearchBySkill = searchRouter.SearchBySkill;
 }

        public static IQueryable<RentCrib> Search(SearchModel queryParams)
        {
            Stack<Expression<Func<RentCrib, bool>>> filters = BuildFilters(queryParams);

            IQueryable<RentCrib> list = Db.RentCribs.Where(x => x.Active).OrderBy(x => x.DatePost);
            var filtered = ApplyFilters(list, filters);
            return filtered;
        }

        public ActionResult List(SearchModel searchModel)
        {
            ProductRepository repository = new ProductRepository();

            List<Product> products = repository.ListAll();

            return Json(products.AsQueryable().ToGridData(searchModel, new[] { "Id", "Name", "CompanyName", "Price" }), JsonRequestBehavior.AllowGet);
        }

        /* Notice the List methid accepts an additional
         * SearchParameter parameter - this is achieved using the -
         * Html.BuildQuery method used in the view Grid declaration */
        public ActionResult List(SearchParameter searchP, SearchModel searchModel)
        {
            StoreRepository repository = new StoreRepository();

            List<Store> stores = repository.ListAll();

            var model = stores.AsQueryable();
            return Json(model.ToGridData(searchModel, new[] { "Id", "Name", "Address" }), JsonRequestBehavior.AllowGet);
        }

        public ActionResult Search(string name, string comm, string addr)
        {
            if (!Authenticate(checkOrgLeadersOnly: true))
                return Content("not authorized");
            Response.NoCache();

            var m = new SearchModel(name, comm, addr);
            return new SearchResult0(m.PeopleList(), m.Count());
        }

 /// <summary>
 /// grid显示函数
 /// </summary>
 /// <param name="searchModel">grid搜索模型</param>
 /// <returns>程序功能节点</returns>
 public ActionResult ListNodes(SearchModel searchModel)
 {
     IQueryable<GeneralProgNode> oPrograms = dbEntity.GeneralProgNodes.Include("Name").Where(p => p.Deleted == false && p.ProgID == progNodeGidGrid).AsQueryable();
     GridColumnModelList<GeneralProgNode> columns = new GridColumnModelList<GeneralProgNode>();
     columns.Add(p => p.Gid).SetAsPrimaryKey();
     columns.Add(p => p.Code);
     columns.Add(p => p.Name.GetResource(CurrentSession.Culture)).SetName("Name.Matter");
     columns.Add(p => (p.Optional == null) ? "": p.Optional.GetResource(CurrentSession.Culture)).SetName("Optional.Matter");
     GridData gridData = oPrograms.ToGridData(searchModel, columns);
     return Json(gridData, JsonRequestBehavior.AllowGet);
 }

        public ActionResult Index(FormCollection form  )
        {
            var model = new SearchModel { City = form["City"], Zip = form["Zip"], };
            if (ModelState.IsValid)
            {

                return RedirectToAction("Index", "Results");
            }
            ModelState.AddModelError(string.Empty, "Oops,  " + string.Join(" ; ", ModelState.Values.SelectMany(x => x.Errors).Select(x => x.ErrorMessage)));
            return View(model);
        }

        /* Creates the grid data */
        public ActionResult ListPersons(SearchModel searchModel)
        {
            List<Person> stores = _persons;

            IQueryable<Person> model =
                (from Person p in stores
                select p).AsQueryable();

            GridData gridData = model.ToGridData(searchModel, Columns.PersonColumns);

            return Json(gridData, JsonRequestBehavior.AllowGet);
        }

        public ActionResult SearchResults(string name, string comm, string addr)
        {
            if (!Authenticate(checkOrgLeadersOnly: true))
                return Content("not authorized");
            if (!CMSRoleProvider.provider.IsUserInRole(AccountModel.UserName2, "Access"))
                return Content("not authorized");
            Response.NoCache();

            DbUtil.LogActivity($"iphone search '{name}'");
            var m = new SearchModel(name, comm, addr);
            return new SearchResult(m.PeopleList(), m.Count());
        }

        public ActionResult ListProgs(SearchModel searchModel)
        {
            IQueryable<GeneralProgNode> oPrograms = dbEntity.GeneralProgNodes.Include("Name").Where(p => p.Deleted == false).AsQueryable();
            int i = 2052;
            GridColumnModelList<GeneralProgNode> columns = new GridColumnModelList<GeneralProgNode>();
            columns.Add(p => p.Gid).SetAsPrimaryKey();
            columns.Add(p => p.Name.GetResource(i)).SetName("Name.Matter");
            columns.Add(p => p.Code);

            GridData gridData = oPrograms.ToGridData(searchModel, columns);
            return Json(gridData, JsonRequestBehavior.AllowGet);
        }

        public void TestSearchMissingEndTimeForPaging()
        {
            DateTime date = DateTime.Now;
            SearchModel<Status> model = new SearchModel<Status>()
            {
                Start = date,
                Paging = 10
            };

            SearchValidationResult res = model.IsValidSearchCombination();
            Assert.False(res.IsValid);
            Assert.AreEqual(StringResource.START_END_VALUES_SHOULD_BE_SPECIFIED, res.Description);
        }

        public void TestSearchMissingStartTime()
        {
            DateTime date = DateTime.Now;
            SearchModel<Status> model = new SearchModel<Status>()
            {
                Status = Status.hold,
                End = date.AddMinutes(5)
            };

            SearchValidationResult res = model.IsValidSearchCombination();
            Assert.False(res.IsValid);
            Assert.AreEqual(StringResource.START_VALUE_SHOULD_BE_SPECIFIED, res.Description);
        }

        public static Stack<Expression<Func<RentCrib, bool>>> BuildFilters(SearchModel queryParams)
        {
            Stack<Expression<Func<RentCrib, bool>>> filters = new Stack<Expression<Func<RentCrib, bool>>>();
            Expression<Func<RentCrib, bool>> inPriceRange;

            if (queryParams.MinPrice != null && queryParams.MaxPrice == null)
            {
                inPriceRange = c => c.MonthlyPrice >= queryParams.MinPrice;
                filters.Push(inPriceRange);
            }
            else if (queryParams.MinPrice == null && queryParams.MaxPrice != null)
            {
                inPriceRange = c => c.MonthlyPrice <= queryParams.MaxPrice;
                filters.Push(inPriceRange);
            }
            else if (queryParams.MinPrice != null && queryParams.MaxPrice != null)
            {
                inPriceRange = c => c.MonthlyPrice >= queryParams.MinPrice && c.MonthlyPrice <= queryParams.MaxPrice;
                filters.Push(inPriceRange);
            }

            if (queryParams.NumberOfRooms != null)
            {
                Expression<Func<RentCrib, bool>> numberOfRoomsFilter = c => c.NumberOfRooms == queryParams.NumberOfRooms;
                filters.Push(numberOfRoomsFilter);
            }

            if (queryParams.Address != null)
            {
                Expression<Func<RentCrib, bool>> addressFilter = c => c.Location.ToUpper().Contains(queryParams.Address.ToUpper());
                filters.Push(addressFilter);
            }

            if (queryParams.KeyWord != null)
            {
                var phrase = queryParams.KeyWord;
                var tokens = phrase.Split(' ');
                foreach (var token in tokens)
                {
                    var token1 = token;
                    Expression<Func<RentCrib, bool>> phraseFilter = c =>
                        (c.Title.ToUpper().Contains(token1.ToUpper())) ||
                        (c.Description.ToUpper().Contains(token1.ToUpper()));
                    filters.Push(phraseFilter);

                }

            }

            return filters;
        }

        public ActionResult Index(SearchModel searchModel)
        {
            string sql = @"select top  " + MaxRowSize + @"  e.BatchNo, d.*,
                        a.OrderNo,a.Item,a.Uom,a.IsCS,a.PlanBill,a.ActBill,a.QualityType, 
                        a.Qty,b.Type,b.Status,a.TransType,b.ExtOrderNo,
                        a.PartyFrom,a.LocFrom,a.PartyTo,b.LocTo,e.*
                        from sconit5_New.dbo.VIEW_LocTrans a
                        left join sconit5_New.dbo.ORD_OrderMstr b on a.OrderNo = b.OrderNo
                        left join sconit5_si.dbo.SAP_InvLoc c on c.SourceId = a.Id
                        left join sconit5_si.dbo.SAP_InvTrans e on (e.FRBNR = c.FRBNR and e.SGTXT = c.SGTXT)
                        left join sconit5_si.dbo.SAP_TransCallBack d on (d.FRBNR = c.FRBNR and d.SGTXT = c.SGTXT)
                        where d.Id>0 and c.SourceType = 0  and e.Status = @p0 and e.CreateDate > @p1 and e.CreateDate < @p2 ";

            TempData["SearchModel"] = searchModel;

            SqlParameter[] sqlParam = new SqlParameter[4];
            sqlParam[0] = new SqlParameter("@p0", searchModel.Status.HasValue ? searchModel.Status.Value : 2);

            if (searchModel.StartDate.HasValue)
            {
                sqlParam[1] = new SqlParameter("@p1", searchModel.StartDate);
            }
            else
            {
                sqlParam[1] = new SqlParameter("@p1", DateTime.Now.AddDays(-1));
            }

            if (searchModel.EndDate.HasValue)
            {
                sqlParam[2] = new SqlParameter("@p2", searchModel.EndDate);
            }
            else
            {
                sqlParam[2] = new SqlParameter("@p2", DateTime.Now);
            }

            if (searchModel.Id.HasValue)
            {
                sql += " and e.Id = @p3 ";
                sqlParam[3] = new SqlParameter("@p3", searchModel.Id);
            }

            sql += " order by d.Id desc ";

            DataSet entity = genericMgr.GetDatasetBySql(sql, sqlParam);

            ViewModel model = new ViewModel();
            model.Data = entity.Tables[0];
            model.Columns = IListHelper.GetColumns(entity.Tables[0]);
            return View(model);
        }