// Suspend ad public bool AdminSuspendAd(int Id) { // get existing try { var obj = CurrentDbContext.ClassifiedDB.Include("Category").Include("SubCategory").Include("Poster").Include("Photos").SingleOrDefault(x => x.Id == Id); if (obj.Status != -1) { obj.Status = -1; obj.NeedApproval = true; obj.Category.TotalClassifiedAdsCount--; obj.SubCategory.ClassifiedAdsCount--; CurrentDbContext.SaveChanges(); // Remove old Lucene LuceneSearch.ClearLuceneIndexRecord(obj.Id, obj.Photos); return(true); } else { return(false); } } catch (Exception) { return(false); } }
public static IEnumerable <ClassifiedAdTitle> GetRecentClassifiedAdIndex(int catId) { // LUCENE // validation // Setup query BooleanQuery bq = new BooleanQuery(); var sortBy = new Sort(); sortBy.SetSort(new SortField("TimeStampTicks", SortField.LONG, true), SortField.FIELD_SCORE); // Get only Open ads bq.Add(NumericRangeQuery.NewIntRange("Status", 0, 0, true, true), Occur.MUST); bq.Add(new TermQuery(new Term("CategoryId", catId.ToString())), Occur.MUST); // Must have Pic //bq.Add(new TermQuery(new Term("AdPhoto")), Occur.MUST); // set up lucene searcher using (var searcher = new IndexSearcher(LuceneSearch._getDir, false)) { var hits_limit = 5; var hits = searcher.Search(bq, null, hits_limit, sortBy).ScoreDocs; var results = LuceneSearch._mapLuceneToDataList <ClassifiedAdTitle>(hits, searcher); return(results); } }
public ActionResult SearchResult(string keyWords) { var lucene = new LuceneSearch(); SearchResult results = lucene.Search(keyWords); return(View(results)); }
public ActionResult GetSearchData(string tbSearchValue) { List <SampleData> searchresult = new LuceneSearch().Search(tbSearchValue).ToList(); return(Json(new { Url = Url.Action("List", searchresult) })); }
public ActionResult Results(string searchstring, string fields) { // validating lucene_index if (!Directory.Exists(LuceneSearch.LuceneDirectory)) { Directory.CreateDirectory(LuceneSearch.LuceneDirectory); } // assigning results List <LuceneData> results = LuceneSearch.Search(searchstring, fields).ToList(); var list = new List <ResultsViewModel.ResultData>(); // converting results to display model foreach (var result in results) { var item = new ResultsViewModel.ResultData { PubDate = DateTime.Parse(result.PubDate), Author = result.Author, Title = result.Title, Tags = result.Tags, Link = result.Link, Entry = result.Description//.Take(30).ToString() // gets first 30 words }; list.Add(item); } // assigning model var model = new ResultsViewModel { Results = list }; return(View(model)); }
/// <summary> /// Remove ad promotion /// </summary> public AdminPromote RemovePromoteAd(int adId) { var demote = CurrentDbContext.ClassifiedDB.Include("AdPromotion").SingleOrDefault(x => x.Id == adId); if (demote == null) { return(null); } // Urgent Ad demote.AdPromotion.UrgentAd.Duration = 0; demote.AdPromotion.UrgentAd.EndDate = null; demote.AdPromotion.UrgentAd.StartDate = null; demote.AdPromotion.UrgentAd.Status = false; // Top Ad demote.AdPromotion.TopAd.Duration = 0; demote.AdPromotion.TopAd.EndDate = null; demote.AdPromotion.TopAd.StartDate = null; demote.AdPromotion.TopAd.Status = false; // Featured Ad demote.AdPromotion.FeaturedAd.Duration = 0; demote.AdPromotion.FeaturedAd.StartDate = null; demote.AdPromotion.FeaturedAd.EndDate = null; demote.AdPromotion.FeaturedAd.Status = false; CurrentDbContext.SaveChanges(); LuceneSearch.AddUpdateLuceneIndex(demote); return(Mapper.Map <AdminPromote>(demote)); }
/// <summary> /// Get most popular ads /// </summary> /// <returns></returns> public static IEnumerable <ClassifiedAdList> GetRandomPickedClassifiedAds() { var randpicks = CacheHelper.GetFromCache <IEnumerable <ClassifiedAdList> >("tbhs-random-home-picks"); if (randpicks == null) { // LUCENE // Setup query BooleanQuery bq = new BooleanQuery(); var sortBy = new Sort(); sortBy.SetSort(new SortField("TimeStampTicks", SortField.LONG, true), SortField.FIELD_SCORE); // Get only Open ads bq.Add(NumericRangeQuery.NewIntRange("Status", 0, 0, true, true), Occur.MUST); // Get Featured only bq.Add(new TermQuery(new Term("FeaturedAdStatus", "False")), Occur.MUST); // Must have Pic bq.Add(new TermQuery(new Term("AdPhotos", "_NULL_")), Occur.MUST_NOT); // set up lucene searcher using (var searcher = new IndexSearcher(LuceneSearch._getDir, false)) { var hits_limit = 1000; var hits = searcher.Search(bq, null, hits_limit, sortBy).ScoreDocs; Shuffle(hits); var results = LuceneSearch._mapLuceneToDataList <ClassifiedAdList>(hits.Take(5), searcher); // save to cache for 5 mins CacheHelper.SaveTocache("tbhs-random-home-picks", results, DateTime.Now.AddMinutes(5)); return(results); } } return(randpicks); }
public ActionResult Search(FormCollection formCollection) { string searchTerm = formCollection["Search"]; IEnumerable <SampleData> results = LuceneSearch.Search(searchTerm, string.Empty); return(View(results)); }
public void Search(string searchTerm, string searchField, bool?searchDefault, int?limit) { List <SampleData> _searchResults; _searchResults = (string.IsNullOrEmpty(searchField) ? LuceneSearch.Search(searchTerm) : LuceneSearch.Search(searchTerm, searchField)).ToList(); if (string.IsNullOrEmpty(searchTerm) && !_searchResults.Any()) { _searchResults = LuceneSearch.GetAllIndexRecords().ToList(); } // limit display number of database records var limitDb = limit == null ? 3 : Convert.ToInt32(limit); List <SampleData> allSampleData; if (limitDb > 0) { allSampleData = SampleDataRepository.GetAll().ToList().Take(limitDb).ToList(); } else { allSampleData = SampleDataRepository.GetAll(); } var AllSampleData = allSampleData; var SearchIndexData = _searchResults; }
public void SaveEvent(Events theEvent) { Events dbEntry = context.Events.Find(theEvent.EventID); if (theEvent.EventID == 0) { context.Events.Add(theEvent); } else { if (dbEntry != null) { var mapping = Mapper.Map(theEvent, dbEntry); if (!string.IsNullOrEmpty(theEvent.ImageMimeType)) { mapping.ImageData = theEvent.ImageData; mapping.ImageMimeType = theEvent.ImageMimeType; } } } if (context.SaveChanges() > 1) { LuceneSearch.AddUpdateLuceneIndex(dbEntry); } }
private void BuildFilter() { foreach (Category c in (CategoryService.GetChildCategoriesByCategoryId(0, true).Where(p => p.Enabled))) { ddlCategory.Items.Add(new ListItem { Text = c.Name, Value = c.CategoryId.ToString(), Selected = Request["category"] == c.CategoryId.ToString() }); } defaultDS.Fields["[ProductCategories].[CategoryID]"].Filter = new InChildCategoriesFieldFilter { CategoryId = ddlCategory.SelectedValue, ParamName = "@CategoryID" }; if (!string.IsNullOrEmpty(Page.Request["name"])) { var name = HttpUtility.UrlDecode(Page.Request["name"]).Trim(); txtName.Text = name; var productIds = LuceneSearch.Search(txtName.Text).AggregateString('/'); defaultDS.TableName += " inner join (select item, sort from [Settings].[ParsingBySeperator](@source,'/') ) as dtt on Product.ProductId=convert(int, dtt.item) "; defaultDS.AddParamSql(new SqlParam { ParamName = "@source", ParamValue = productIds }); if (_sort == SortOrder.NoSorting) { defaultDS.Fields.Add("sort", new Field("sort")); defaultDS.Fields["sort"].Sorting = SortDirection.Ascending; } SearchTerm = HttpUtility.HtmlEncode(name); } filterPrice.CategoryId = 0; filterPrice.InDepth = true; if (!string.IsNullOrEmpty(Request["pricefrom"]) || !string.IsNullOrEmpty(Request["priceto"])) { int pricefrom = Request["pricefrom"].TryParseInt(0); int priceto = Request["priceto"].TryParseInt(int.MaxValue); filterPrice.CurValMin = pricefrom; filterPrice.CurValMax = priceto; defaultDS.Fields["discountPrice"].Filter = new RangeFieldFilter { ParamName = "@priceRange", From = pricefrom * CurrencyService.CurrentCurrency.Value, To = priceto * CurrencyService.CurrentCurrency.Value }; } else { filterPrice.CurValMin = 0; filterPrice.CurValMax = int.MaxValue; } }
private void BuildFilter() { _paging.Where("Enabled={0}", true); _paging.Where("AND CategoryEnabled={0}", true); foreach (var c in (CategoryService.GetChildCategoriesByCategoryId(0, true).Where(p => p.Enabled))) { ddlCategory.Items.Add(new ListItem { Text = c.Name, Value = c.CategoryId.ToString(), }); } var listItem = ddlCategory.Items.FindByValue(Request["category"]); if (listItem != null) { ddlCategory.SelectedValue = listItem.Value; } _paging.Where("AND Exists( select 1 from [Catalog].[ProductCategories] INNER JOIN [Settings].[GetChildCategoryByParent]({0}) AS hCat ON hCat.id = [ProductCategories].[CategoryID] and ProductCategories.ProductId = [Product].[ProductID])", ddlCategory.SelectedValue); if (!string.IsNullOrEmpty(Page.Request["name"])) { var name = HttpUtility.UrlDecode(Page.Request["name"]).Trim(); txtName.Text = name; var productIds = LuceneSearch.Search(txtName.Text).AggregateString('/'); _paging.Inner_Join("(select item, sort from [Settings].[ParsingBySeperator]({0},'/') ) as dtt on Product.ProductId=convert(int, dtt.item)", productIds); if (_sort == ESortOrder.NoSorting) { _paging.OrderBy("dtt.sort ASC"); } SearchTerm = HttpUtility.HtmlEncode(name); } filterPrice.CategoryId = 0; filterPrice.InDepth = true; if (!string.IsNullOrEmpty(Request["pricefrom"]) || !string.IsNullOrEmpty(Request["priceto"])) { var pricefrom = Request["pricefrom"].TryParseInt(0); var priceto = Request["priceto"].TryParseInt(int.MaxValue); filterPrice.CurValMin = pricefrom; filterPrice.CurValMax = priceto; _paging.Where("and Exists( select 1 from [Catalog].[Offer] where Offer.Price - Offer.Price * Discount / 100 >= {0} ", pricefrom * CurrencyService.CurrentCurrency.Value); _paging.Where("AND Offer.Price - Offer.Price * Discount / 100 <={0} and Offer.ProductId = [Product].[ProductID])", priceto * CurrencyService.CurrentCurrency.Value); } else { filterPrice.CurValMin = 0; filterPrice.CurValMax = int.MaxValue; } }
public ActionResult UpdateIndex() { LuceneSearch.ClearLuceneIndex(); var x = SampleDataRepository.GetAll(); LuceneSearch.AddUpdateLuceneIndex(x); return(RedirectToAction("Index")); }
/// <summary> /// update product /// </summary> /// <param name="product"></param> /// <param name="sentToLuceneIndex"></param> /// <param name="db"></param> /// <returns></returns> public static bool UpdateProduct(Product product, bool sentToLuceneIndex, SQLDataAccess db) { db.cmd.CommandText = "[Catalog].[sp_UpdateProductById]"; db.cmd.CommandType = CommandType.StoredProcedure; db.cmd.Parameters.Clear(); db.cmd.Parameters.AddWithValue("@ArtNo", product.ArtNo); db.cmd.Parameters.AddWithValue("@Name", product.Name); db.cmd.Parameters.AddWithValue("@ProductID", product.ProductId); db.cmd.Parameters.AddWithValue("@Ratio", product.Ratio); db.cmd.Parameters.AddWithValue("@Discount", product.Discount); db.cmd.Parameters.AddWithValue("@Weight", product.Weight); db.cmd.Parameters.AddWithValue("@Size", (product.Size ?? ((object)DBNull.Value))); db.cmd.Parameters.AddWithValue("@IsFreeShipping", product.IsFreeShipping); db.cmd.Parameters.AddWithValue("@ItemsSold", product.ItemsSold); db.cmd.Parameters.AddWithValue("@BriefDescription", (product.BriefDescription ?? ((object)DBNull.Value))); db.cmd.Parameters.AddWithValue("@Description", (product.Description ?? ((object)DBNull.Value))); db.cmd.Parameters.AddWithValue("@Enabled", product.Enabled); db.cmd.Parameters.AddWithValue("@OrderByRequest", product.OrderByRequest); db.cmd.Parameters.AddWithValue("@Recomended", product.Recomended); db.cmd.Parameters.AddWithValue("@New", product.New); db.cmd.Parameters.AddWithValue("@BestSeller", product.BestSeller); db.cmd.Parameters.AddWithValue("@OnSale", product.OnSale); db.cmd.Parameters.AddWithValue("@BrandID", product.BrandId == 0 ? ((object)DBNull.Value) : product.BrandId); db.cmd.Parameters.AddWithValue("@UrlPath", product.UrlPath); db.cmd.ExecuteNonQuery(); SetProductHierarchicallyEnabled(product.ProductId); if (product.Offers != null && product.Offers.Count > 0) { OfferService.UpdateOffersByProductId(product.ProductId, product.Offers); } if (product.Meta != null) { if (product.Meta.Title.IsNullOrEmpty() && product.Meta.MetaKeywords.IsNullOrEmpty() && product.Meta.MetaDescription.IsNullOrEmpty()) { if (MetaInfoService.IsMetaExist(product.ProductId, MetaType.Product)) { MetaInfoService.DeleteMetaInfo(product.ProductId, MetaType.Product); } } else { MetaInfoService.SetMeta(product.Meta); } } if (sentToLuceneIndex) { LuceneSearch.AddUpdateLuceneIndex(new SampleData(product.ProductId, product.ArtNo, product.Name)); } return(true); }
public bool Refresh() { using (var lucene = new LuceneSearch()) { lucene.RefreshIndexes(); } return(true); }
public ActionResult Index() { using (ApplicationDbContext db = new ApplicationDbContext()) { LuceneSearch.ClearLuceneIndex(); LuceneSearch.AddUpdateLuceneIndex(db.Creatives); } return(View()); }
public ActionResult Search(string locale = "en-US") { // check session if timeout if (SSO_SessionTimeout()) { SSO_ClearSession(); } SSO_InternalKeepAlive(); SSO_InternalHeartbeat(); var session = getSession(); if (session != null && !session.isKeptAlive) { Session["isKeptAlive"] = true; } var keys = Request.QueryString.Keys; for (var i = 0; i < keys.Count; i++) { var val = Request.QueryString[keys[i]]; if (keys[i] == "q" && val != null && val != "") { List <LuceneSearchData> searchData = LuceneSearch.Search(val).ToList(); foreach (LuceneSearchData data in searchData) { data.Name = data.GetName(locale); data.Description = data.GetDesc(locale); data.Url = data.GetURL(locale); } BaseViewModel vm = BaseViewModel.make(locale, "home", null, Request, session); vm.search_keywords = val; vm.search_data = searchData; if (locale != null) { Session["LANG"] = locale; } return(View(vm)); } } BaseViewModel vm2 = BaseViewModel.make(locale, "home", null, Request, session); vm2.search_keywords = ""; vm2.search_data = new List <LuceneSearchData>(); if (locale != null) { Session["LANG"] = locale; } return(View(vm2)); }
public JsonResult UpdateLucene() { var lucene = new LuceneSearch(); lucene.AddIndexes(bll.Products.GetAll()); lucene.AddIndexes(bll.Customers.GetAll()); lucene.AddIndexes(bll.Orders.GetAll()); lucene.AddIndexes(bll.Suppliers.GetAll()); return(Json((object)true)); }
private static void Main(String[] args) { Console.WriteLine($"{System.AppDomain.CurrentDomain.FriendlyName} started."); // Test LuceneSearch.LuceneDir = BuildAppPath(); Console.WriteLine($"App path = {LuceneSearch.LuceneDir}"); LuceneSearch.AddUpdateLuceneIndex(SampleDataRepository.GetAll()); Console.WriteLine("Hit any key to terminate"); Console.ReadKey(); }
public QueryMaker(Analyzer analyzer, LuceneSearch luceneSearch, List <KeyValuePair <string, object> > searchCriterion) { _analyzer = analyzer; _luceneSearch = luceneSearch; _searchCriterion = searchCriterion; _kvpMax = searchCriterion.First(kvp => kvp.Key.Equals("CardAdoptionDateMax")); _kvpMin = searchCriterion.FirstOrDefault(kvp => kvp.Key == "CardAdoptionDateMin"); }
public void AdminUpdateLuceneSearchEngine() { IEnumerable <ClassifiedAdLucene> ads = CurrentDbContext.ClassifiedDB.ProjectTo <ClassifiedAdLucene>().Where(x => x.Status == 0 || x.Status == 1 || x.Status == 2).ToList(); if (ads != null && ads.Count() > 0) { LuceneSearch.ClearAllLuceneIndexRecords(); LuceneSearch.AdminCreateLuceneIndex(ads); } }
public void Enumerable(LuceneSearch luceneSearch) { IQueryBuilder queryBuilder = new QueryBuilder(); queryBuilder.Term(BBCFields.Title, "africa"); var result = luceneSearch.Execute(queryBuilder); WriteDocuments(result); Assert.AreEqual(8, result.Count()); }
public void EnumerableWithWhere(LuceneSearch luceneSearch) { IQueryBuilder queryBuilder = new QueryBuilder(); queryBuilder.Term(BBCFields.Title, "africa"); var result = luceneSearch.Execute(queryBuilder).Where(doc => doc.GetField(BBCFields.Title).StringValue.IndexOf("your", StringComparison.OrdinalIgnoreCase) >= 0); WriteDocuments(result); Assert.AreEqual(1, result.Count()); }
public void Execute(IJobExecutionContext context) { var data = LuceneSearchDataRepository.GetAll(); LuceneSearch.AddUpdateLuceneIndex(LuceneSearchDataRepository.GetAll()); AuditLogDbContext.getInstance().createAuditLog(new WebApplication2.Models.AuditLog { action = "[Search]", remarks = "Indexing data count: " + data.Count, }); }
public string ClearIndex() { if (LuceneSearch.ClearLuceneIndex()) { return("Search index was cleared successfully!"); } else { return("Index is locked and cannot be cleared, try again later or clear manually!"); } }
public void ChainedTerms(LuceneSearch luceneSearch) { IQueryBuilder queryBuilder = new QueryBuilder(); queryBuilder.Setup ( x => x.WildCard(BBCFields.Description, "a*"), x => x.Term(BBCFields.Description, "police") ); ExecuteAndAssert(luceneSearch, queryBuilder, 17); }
public IEnumerable <SearchEntry> Get(string query) { IEnumerable <SearchEntry> results = new List <SearchEntry>(); using (var lucene = new LuceneSearch()) { results = lucene.Search(query); } return(results); }
public void Add(T model) { _validationProvider.Validate(model); if (!_validationProvider.HasErrors) { _repository.Add(model); LuceneSearch.AddOrUpdateLuceneIndex(model); } }
public void Configuration(IAppBuilder app) { List <Post> posts = null; using (PostContext db = new PostContext()) { posts = db.Posts.ToList(); LuceneSearch.AddUpdateLuceneIndex(posts); } // Дополнительные сведения о настройке приложения см. на странице https://go.microsoft.com/fwlink/?LinkID=316888 }
public string SearchResult(Search search) { IEnumerable <Creative> creatives = LuceneSearch.Search(search.Row); if (creatives.Count() == 0) { return(null); } return(HomePageService.SearchResult(creatives)); }
public ActionResult NavBar() { LuceneSearch.AddUpdateLuceneIndex(_repository.Events); NavbarViewModel model = new NavbarViewModel { Categories = _categoryRep.Categories, SubCategories = _categoryRep.SubCategories }; return(PartialView("NavBarSummary", model)); }
private IEnumerable <CardCriterion> GetSearchResultBasedOnSearchType() { _luceneSearch = new LuceneSearch(_criteriaList); if (_isLuceneSyntax) { return(_luceneSearch.SearchWithLuceneSyntax()); } else { return(_luceneSearch.SearchNoLuceneSyntax()); } }
/// <summary> /// delete product by productId /// </summary> /// <param name="productId"></param> /// <param name="sentToLuceneIndex"></param> /// <returns></returns> public static bool DeleteProduct(int productId, bool sentToLuceneIndex) { PhotoService.DeletePhotos(productId, PhotoType.Product); DeleteRelatedProducts(productId); SQLDataAccess.ExecuteNonQuery("[Catalog].[sp_DeleteProduct]", CommandType.StoredProcedure, new SqlParameter("@ProductID", productId)); CategoryService.ClearCategoryCache(); if (sentToLuceneIndex) { LuceneSearch.ClearLuceneIndexRecord(productId); } return(true); }
public void Group(LuceneSearch luceneSearch) { IQueryBuilder queryBuilder = new QueryBuilder(); queryBuilder.Setup ( x => x.WildCard(BBCFields.Title, "africa"), x => x.Group().Setup ( y => y.Term(BBCFields.Description, "africa", BooleanClause.Occur.SHOULD), y => y.Term(BBCFields.Description, "amazing", BooleanClause.Occur.SHOULD) ) ); ExecuteAndAssert(luceneSearch, queryBuilder, 5); }
public void BoostedCaseInsensitiveMandatoryTerm(LuceneSearch luceneSearch) { BooleanQuery originalQuery = new BooleanQuery(); Term term = new Term("_name", "value"); TermQuery termQuery = new TermQuery(term); originalQuery.Add(termQuery, Occur.MUST); termQuery.Boost = 10; string queryString = originalQuery.ToString(); IQueryable<Document> luceneQueryable = luceneSearch.GetQueryable(); var items = luceneQueryable.Where(x => x.Term("_name", "Value")); //Query replacementQuery = luceneQueryable.Build(); // string newQueryString = replacementQuery.ToString(); // Assert.AreEqual(queryString, newQueryString); Console.Write(queryString); }
public void CollectDailyCount(LuceneSearch luceneSearch) { IQueryBuilder queryBuilder = new QueryBuilder(); queryBuilder.Setup ( x => x.WildCard(BBCFields.PublishDate, "*") ); DateCollector collector = new DateCollector(); luceneSearch.Collect(queryBuilder.Build(), collector); foreach (String day in collector.DailyCount.Keys) { Console.Error.WriteLine("Day: {0} had {1} documents", day, collector.DailyCount[day]); } Console.WriteLine(); }
public void MultipleSortingDescending(LuceneSearch luceneSearch) { IQueryBuilder queryBuilder = new QueryBuilder(); queryBuilder.Setup ( x => x.WildCard(BBCFields.Description, "a*"), x => x.Sort(BBCFields.SecondarySort, true), x => x.Sort(BBCFields.Sortable, true) ); ILuceneSearchResult result = ExecuteAndAssert(luceneSearch, queryBuilder, 902); List<Document> documents = result.GetPagedDocuments(0, 1000); for (var i = 1; i < documents.Count; i++) { string thisDocumentSortable = GetSecondarySortString(documents[i]); string lastDocumentSortable = GetSecondarySortString(documents[i - 1]); Assert.IsTrue(String.Compare(lastDocumentSortable, thisDocumentSortable, StringComparison.Ordinal) >= 0); } }
public void Paging(LuceneSearch luceneSearch) { IQueryBuilder queryBuilder = new QueryBuilder(); queryBuilder.Setup(x => x.WildCard(BBCFields.Description, "a*")); var results = ExecuteAndAssertPaged(luceneSearch, queryBuilder, 902, 0, 10); var documents = results.GetPagedDocuments(0, 9); Assert.AreEqual(10, documents.Count); var results2 = ExecuteAndAssertPaged(luceneSearch, queryBuilder, 902, 1, 11); var documents2 = results2.GetPagedDocuments(1, 10); Assert.AreEqual(10, documents2.Count); for (var i = 0; i < documents.Count - 1; i++) { Assert.AreEqual(documents2[i].GetValues(BBCFields.Title).FirstOrDefault(), documents[i+1].GetValues(BBCFields.Title).FirstOrDefault()); } }
public void PhraseDistance(LuceneSearch luceneSearch) { IQueryBuilder queryBuilder = new QueryBuilder(); queryBuilder.Phrase(2).AddTerm(BBCFields.Title, "wildlife").AddTerm(BBCFields.Title, "africa"); var results = ExecuteAndAssert(luceneSearch, queryBuilder, 1); }
public void EasyOr(LuceneSearch luceneSearch) { IQueryBuilder queryBuilder = new QueryBuilder(); queryBuilder.Terms(BBCFields.Title, new[] {"europe", "africa"}, Matches.Sometimes); ExecuteAndAssert(luceneSearch, queryBuilder, 12); }
public void Fuzzy(LuceneSearch luceneSearch) { IQueryBuilder queryBuilder = new QueryBuilder(); queryBuilder.Fuzzy(BBCFields.Title, "afric"); var results = ExecuteAndAssert(luceneSearch, queryBuilder, 16); }
public void RemoveAndReexecute(LuceneSearch luceneSearch) { IQueryBuilder queryBuilder = new QueryBuilder(); queryBuilder.Term(BBCFields.Title, "africa", key: "africacriteria"); var results = ExecuteAndAssert(luceneSearch, queryBuilder, 8); queryBuilder.Queries.Remove("africacriteria"); queryBuilder.Term(BBCFields.Title, "report", key: "businesscriteria"); Console.WriteLine("\r\nSecond Criteria"); var results2 = ExecuteAndAssert(luceneSearch, queryBuilder, 5); Assert.AreNotEqual(results.TotalHits, results2.TotalHits); }
public void Term(LuceneSearch luceneSearch) { IQueryBuilder queryBuilder = new QueryBuilder(); queryBuilder.Term(BBCFields.Title, "africa"); var results = ExecuteAndAssert(luceneSearch, queryBuilder, 8); Assert.AreEqual(8, results.TotalHits); IQueryBuilder alternative = new QueryBuilder(); alternative.Where(x => x.Term("_name", "work")); var results2 = luceneSearch.Execute(queryBuilder); Assert.AreEqual(results.TotalHits, results2.TotalHits); }
public void SimpleOrClauseSuccessful(LuceneSearch luceneSearch) { IQueryBuilder queryBuilder = new QueryBuilder(); queryBuilder.Or ( x => x.Term(BBCFields.Title, "africa"), x => x.Term(BBCFields.Title, "europe") ); ExecuteAndAssert(luceneSearch, queryBuilder, 12); }
public void WildCard(LuceneSearch luceneSearch) { IQueryBuilder queryBuilder = new QueryBuilder(); queryBuilder.Setup(x => x.WildCard(BBCFields.Description, "a*")); ExecuteAndAssert(luceneSearch, queryBuilder, 902); }
public void Sorting(LuceneSearch luceneSearch) { IQueryBuilder queryBuilder = new QueryBuilder(); queryBuilder.Setup ( x => x.WildCard(BBCFields.Description, "a*"), x => x.Sort(BBCFields.Sortable) ); ILuceneSearchResult result = ExecuteAndAssert(luceneSearch, queryBuilder, 902); List<Document> documents = result.GetPagedDocuments(0, 100); for (var i = 1; i < documents.Count; i++) { string thisDocumentSortable = documents[i].GetValues(BBCFields.Sortable).FirstOrDefault(); string lastDocumentSortable = documents[i - 1].GetValues(BBCFields.Sortable).FirstOrDefault(); Assert.IsTrue(String.Compare(thisDocumentSortable, lastDocumentSortable, StringComparison.Ordinal) >= 0); } }
public void SpeedExample(LuceneSearch luceneSearch) { Console.WriteLine("A simple test to show Lucene getting quicker as queries are done"); Console.WriteLine("----------------------------------------------------------------"); Console.WriteLine(); Console.WriteLine("Pass 1"); SpeedExampleExecute(luceneSearch, "b"); Console.WriteLine(); Console.WriteLine("Pass 2"); SpeedExampleExecute(luceneSearch, "c"); Console.WriteLine(); Console.WriteLine("Pass 3"); SpeedExampleExecute(luceneSearch, "a"); Console.WriteLine(); Console.WriteLine("** Repeating Passes **"); Console.WriteLine("Repeat Pass 1"); SpeedExampleExecute(luceneSearch, "b"); Console.WriteLine(); Console.WriteLine("Repeat Pass 2"); SpeedExampleExecute(luceneSearch, "c"); Console.WriteLine(); Console.WriteLine("Repeat Pass 3"); SpeedExampleExecute(luceneSearch, "a"); }
public void SpeedExampleExecute(LuceneSearch luceneSearch, string startingCharacter) { // Chosen due to it being the slowest query IQueryBuilder queryBuilder = new QueryBuilder(); queryBuilder.Setup ( x => x.WildCard(BBCFields.Description, startingCharacter + "*"), x => x.Term(BBCFields.Description, "sport") ); var result = luceneSearch.Execute(queryBuilder); Console.WriteLine("Total Results: {0}", result.TotalHits); Console.WriteLine("Elapsed Time: {0}", result.ElapsedTimeMs); }
public void Setup() { search = new LuceneSearch(""); }
public void Group(LuceneSearch luceneSearch) { IQueryBuilder queryBuilder = new QueryBuilder(); queryBuilder.Setup ( x => x.WildCard(BBCFields.Title, "africa"), x => x.Group().Setup ( y => y.Term(BBCFields.Description, "africa", Matches.Sometimes), y => y.Term(BBCFields.Description, "amazing", Matches.Sometimes) ) ); ExecuteAndAssert(luceneSearch, queryBuilder, 5); }
public void EasyAnd(LuceneSearch luceneSearch) { IQueryBuilder queryBuilder = new QueryBuilder(); queryBuilder.Terms(BBCFields.Title, new[] { "africa", "road" }, occur: BooleanClause.Occur.MUST); ExecuteAndAssert(luceneSearch, queryBuilder, 1); }
private ILuceneSearchResult ExecuteAndAssertPaged(LuceneSearch luceneSearch, IQueryBuilder queryBuilder, int numberOfHitsExpected, int start, int end) { // Search = new LuceneSearch(GeneralConstants.Paths.BBCIndex); var result = luceneSearch.Execute(queryBuilder); List<Document> documents = result.GetPagedDocuments(start, end); Console.WriteLine("Searched {0} documents in {1} ms", luceneSearch.IndexSearcher.MaxDoc, result.ElapsedTimeMs); Console.WriteLine(); WriteDocuments(documents); Assert.AreEqual(numberOfHitsExpected, result.TotalHits); return result; }
public void SetupSyntax(LuceneSearch luceneSearch) { IQueryBuilder queryBuilder = new QueryBuilder(); queryBuilder.Setup(x => x.Term(BBCFields.Title, "africa")); ExecuteAndAssert(luceneSearch, queryBuilder, 8); }
public void TermRange(LuceneSearch luceneSearch) { IQueryBuilder queryBuilder = new QueryBuilder(); DateTime startDate = new DateTime(2012, 12, 1); DateTime endDate = new DateTime(2013, 1, 1); queryBuilder.TermRange(BBCFields.PublishDate, TestHelpers.GetDateString(startDate), TestHelpers.GetDateString(endDate)); ExecuteAndAssert(luceneSearch, queryBuilder, 60); }
public void EasyOr(LuceneSearch luceneSearch) { IQueryBuilder queryBuilder = new QueryBuilder(); queryBuilder.Terms(BBCFields.Title, new[] {"europe", "africa"}, BooleanClause.Occur.SHOULD); ExecuteAndAssert(luceneSearch, queryBuilder, 12); }
public void Setup() { filesystemSearch = new LuceneSearch(GeneralConstants.Paths.BBCIndex); }
public void EasyAnd(LuceneSearch luceneSearch) { IQueryBuilder queryBuilder = new QueryBuilder(); queryBuilder.Terms(BBCFields.Title, new[] { "africa", "road" }, occur: Matches.Always); ExecuteAndAssert(luceneSearch, queryBuilder, 1); }
private ILuceneSearchResult ExecuteAndAssert(LuceneSearch luceneSearch, IQueryBuilder queryBuilder, int numberOfHitsExpected) { var result = luceneSearch.Execute(queryBuilder); var documents = result.GetTopDocuments(); Console.WriteLine("Searched {0} documents in {1} ms", luceneSearch.IndexSearcher.MaxDoc, result.ElapsedTimeMs); Console.WriteLine(); WriteDocuments(documents); Assert.AreEqual(numberOfHitsExpected, result.TotalHits); return result; }