// 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;
}
