Пример #1
0
        private static IList <int> SearchCore(SearchFilter searchFilter)
        {
            if (!Directory.Exists(LuceneCommon.IndexDirectory))
            {
                return(new int[0]);
            }

            SortField sortField  = GetSortField(searchFilter);
            int       numRecords = Math.Min((1 + searchFilter.Skip) * searchFilter.Take, MaximumRecordsToReturn);

            using (var directory = new LuceneFileSystem(LuceneCommon.IndexDirectory))
            {
                var searcher = new IndexSearcher(directory, readOnly: true);
                var query    = ParseQuery(searchFilter);

                Filter filter = null;
                if (!searchFilter.IncludePrerelease)
                {
                    var isLatestStableQuery = new TermQuery(new Term("IsLatestStable", Boolean.TrueString));
                    filter = new QueryWrapperFilter(isLatestStableQuery);
                }

                var results = searcher.Search(query, filter: filter, n: numRecords, sort: new Sort(sortField));
                var keys    = results.scoreDocs.Skip(searchFilter.Skip)
                              .Select(c => ParseKey(searcher.Doc(c.doc).Get("Key")))
                              .ToList();
                searcher.Close();
                return(keys);
            }
        }
Пример #2
0
        private static IList <int> SearchCore(SearchFilter searchFilter, out int totalHits)
        {
            if (!Directory.Exists(LuceneCommon.IndexDirectory))
            {
                totalHits = 0;
                return(new int[0]);
            }

            SortField sortField  = GetSortField(searchFilter);
            int       numRecords = searchFilter.Skip + searchFilter.Take;

            using (var directory = new LuceneFileSystem(LuceneCommon.IndexDirectory))
            {
                var searcher = new IndexSearcher(directory, readOnly: true);
                var query    = ParseQuery(searchFilter);

                var    filterTerm = searchFilter.IncludePrerelease ? "IsLatest" : "IsLatestStable";
                var    termQuery  = new TermQuery(new Term(filterTerm, Boolean.TrueString));
                Filter filter     = new QueryWrapperFilter(termQuery);


                var results = searcher.Search(query, filter: filter, n: numRecords, sort: new Sort(sortField));
                var keys    = results.scoreDocs.Skip(searchFilter.Skip)
                              .Select(c => ParseKey(searcher.Doc(c.doc).Get("Key")))
                              .ToList();

                totalHits = results.totalHits;
                searcher.Close();
                return(keys);
            }
        }
        private static IList<int> SearchCore(SearchFilter searchFilter, out int totalHits)
        {
            if (!Directory.Exists(LuceneCommon.IndexDirectory))
            {
                totalHits = 0;
                return new int[0];
            }

            SortField sortField = GetSortField(searchFilter);
            int numRecords = searchFilter.Skip + searchFilter.Take;

            using (var directory = new LuceneFileSystem(LuceneCommon.IndexDirectory))
            {
                var searcher = new IndexSearcher(directory, readOnly: true);
                var query = ParseQuery(searchFilter);

                var filterTerm = searchFilter.IncludePrerelease ? "IsLatest" : "IsLatestStable";
                var termQuery = new TermQuery(new Term(filterTerm, Boolean.TrueString));
                Filter filter = new QueryWrapperFilter(termQuery);
                

                var results = searcher.Search(query, filter: filter, n: numRecords, sort: new Sort(sortField));
                var keys = results.scoreDocs.Skip(searchFilter.Skip)
                                            .Select(c => ParseKey(searcher.Doc(c.doc).Get("Key")))
                                            .ToList();

                totalHits = results.totalHits;
                searcher.Close();
                return keys;
            }
        }
 protected internal virtual void WriteIndex(bool creatingIndex, List <PackageIndexEntity> packages)
 {
     using (var directory = new LuceneFileSystem(LuceneCommon.IndexDirectory))
     {
         var analyzer    = new StandardAnalyzer(LuceneCommon.LuceneVersion);
         var indexWriter = new IndexWriter(directory, analyzer, create: creatingIndex, mfl: IndexWriter.MaxFieldLength.UNLIMITED);
         AddPackages(indexWriter, packages);
         indexWriter.Close();
     }
 }
        private static IEnumerable <int> SearchCore(string searchTerm)
        {
            if (!Directory.Exists(LuceneCommon.IndexDirectory))
            {
                return(Enumerable.Empty <int>());
            }

            using (var directory = new LuceneFileSystem(LuceneCommon.IndexDirectory))
            {
                var searcher = new IndexSearcher(directory, readOnly: true);
                var query    = ParseQuery(searchTerm);
                var results  = searcher.Search(query, filter: null, n: 1000, sort: new Sort(new[] { SortField.FIELD_SCORE, new SortField("DownloadCount", SortField.INT, reverse: true) }));
                var keys     = results.scoreDocs.Select(c => Int32.Parse(searcher.Doc(c.doc).Get("Key"), CultureInfo.InvariantCulture))
                               .ToList();
                searcher.Close();
                return(keys);
            }
        }
 public void UpdateIndex()
 {
     DateTime? lastWriteTime = GetLastWriteTime();
     bool creatingIndex = lastWriteTime == null;
     using (var context = new EntitiesContext())
     {
         var packages = GetPackages(context, lastWriteTime);
         if (packages.Any())
         {
             using (var directory = new LuceneFileSystem(LuceneCommon.IndexPath))
             {
                 var analyzer = new StandardAnalyzer(LuceneCommon.LuceneVersion);
                 var indexWriter = new IndexWriter(directory, analyzer, create: creatingIndex, mfl: IndexWriter.MaxFieldLength.UNLIMITED);
                 AddPackages(indexWriter, packages);
                 indexWriter.Close();
             }
         }
     }
     UpdateLastWriteTime();
 }
        private static IEnumerable<int> SearchCore(string searchTerm)
        {
            if (!Directory.Exists(LuceneCommon.IndexPath))
            {
                return Enumerable.Empty<int>();
            }

            using (var directory = new LuceneFileSystem(LuceneCommon.IndexPath))
            {
                var searcher = new IndexSearcher(directory, readOnly: true);

                var boosts = new Dictionary<string, float> { { "Id-Exact", 5.0f }, { "Id", 2.0f }, { "Title", 1.5f }, { "Description", 0.8f } };
                var analyzer = new StandardAnalyzer(LuceneCommon.LuceneVersion);
                var queryParser = new MultiFieldQueryParser(LuceneCommon.LuceneVersion, new[] { "Id-Exact", "Id", "Title", "Author", "Description", "Tags" }, analyzer, boosts);

                var query = queryParser.Parse(searchTerm);
                var results = searcher.Search(query, filter: null, n: 1000, sort: Sort.RELEVANCE);
                var keys = results.scoreDocs.Select(c => Int32.Parse(searcher.Doc(c.doc).Get("Key"), CultureInfo.InvariantCulture))
                                            .ToList();
                searcher.Close();
                return keys;
            }
        }
        private static IEnumerable<int> SearchCore(string searchTerm)
        {
            if (!Directory.Exists(LuceneCommon.IndexDirectory))
            {
                return Enumerable.Empty<int>();
            }

            using (var directory = new LuceneFileSystem(LuceneCommon.IndexDirectory))
            {
                var searcher = new IndexSearcher(directory, readOnly: true);
                var query = ParseQuery(searchTerm);
                var results = searcher.Search(query, filter: null, n: 1000, sort: new Sort(new[] { SortField.FIELD_SCORE, new SortField("DownloadCount", SortField.INT, reverse: true) }));
                var keys = results.scoreDocs.Select(c => Int32.Parse(searcher.Doc(c.doc).Get("Key"), CultureInfo.InvariantCulture))
                                            .ToList();
                searcher.Close();
                return keys;
            }
        }
 protected internal virtual void WriteIndex(bool creatingIndex, List<PackageIndexEntity> packages)
 {
     using (var directory = new LuceneFileSystem(LuceneCommon.IndexDirectory))
     {
         var analyzer = new StandardAnalyzer(LuceneCommon.LuceneVersion);
         var indexWriter = new IndexWriter(directory, analyzer, create: creatingIndex, mfl: IndexWriter.MaxFieldLength.UNLIMITED);
         AddPackages(indexWriter, packages);
         indexWriter.Close();
     }
 }
Пример #10
0
        private static IList<int> SearchCore(SearchFilter searchFilter)
        {
            if (!Directory.Exists(LuceneCommon.IndexDirectory))
            {
                return new int[0];
            }

            SortField sortField = GetSortField(searchFilter);
            int numRecords = Math.Min((1 + searchFilter.Skip) * searchFilter.Take, MaximumRecordsToReturn);

            using (var directory = new LuceneFileSystem(LuceneCommon.IndexDirectory))
            {
                var searcher = new IndexSearcher(directory, readOnly: true);
                var query = ParseQuery(searchFilter);

                Filter filter = null;
                if (!searchFilter.IncludePrerelease)
                {
                    var isLatestStableQuery = new TermQuery(new Term("IsLatestStable", Boolean.TrueString));
                    filter = new QueryWrapperFilter(isLatestStableQuery);
                }

                var results = searcher.Search(query, filter: filter, n: numRecords, sort: new Sort(sortField));
                var keys = results.scoreDocs.Skip(searchFilter.Skip)
                                            .Select(c => ParseKey(searcher.Doc(c.doc).Get("Key")))
                                            .ToList();
                searcher.Close();
                return keys;
            }
        }