Example #1
0
        public Hashtable GetStoredUriStrings(string server, string file)
        {
            Hashtable uris = new Hashtable();

            Term term = new Term(PropertyToFieldName(PropertyType.Keyword, "fixme:file"), file);

            LNS.QueryFilter filter = new LNS.QueryFilter(new LNS.TermQuery(term));

            term = new Term(PropertyToFieldName(PropertyType.Keyword, "fixme:account"), server);
            LNS.TermQuery query = new LNS.TermQuery(term);

            LNS.IndexSearcher searcher = LuceneCommon.GetSearcher(PrimaryStore);
            LNS.Hits          hits     = searcher.Search(query, filter);

            for (int i = 0; i < hits.Length(); i++)
            {
                StoredInfo info = DocumentToStoredInfo(hits.Doc(i));
                uris.Add(info.Uri.ToString(), info.FullyIndexed);
            }

            LuceneCommon.ReleaseSearcher(searcher);

            return(uris);
        }
        public static List<List<FacetReturn>> GetFacets(List<SearchStringModel> _searchQuery)
        {
            var ret = new List<List<FacetReturn>>();
            var facets = Context.ContentDatabase.GetItem(Constants.FacetFolder).Children;
            foreach (Item facet in facets)
            {
                if (facet.Fields["Enabled"].Value == "1")
                {
                    var type = Activator.CreateInstance(Type.GetType(facet.Fields["Type"].Value));
                    if ((type as IFacet).IsNotNull())
                    {
                        var locationOverride = GetLocationOverride(_searchQuery);
                        var indexName = BucketManager.GetContextIndex(Context.ContentDatabase.GetItem(locationOverride));
                        using (var searcher = new IndexSearcher(indexName))
                        using (var context = new SortableIndexSearchContext(searcher.Index))
                        {
                            var query = SearchHelper.GetBaseQuery(_searchQuery, locationOverride);
                            var queryBase = searcher.ContructQuery(query);
                            var searchBitArray = new QueryFilter(queryBase).Bits(context.Searcher.GetIndexReader());
                            var res = ((IFacet)type).Filter(queryBase, _searchQuery, locationOverride, searchBitArray);
                            ret.Add(res);
                        }
                    }
                }
            }

            return ret;
        }
Example #3
0
        public virtual QueryFilter GenreQueryFilter(Query query, bool isFacet, bool isIdLookup, string termName, string terms)
        {
            var tempTerms = terms;
            var newGuid = new Guid();
            var isGuid = Guid.TryParse(terms, out newGuid);
            if (isGuid)
            {
                tempTerms = IdHelper.NormalizeGuid(terms, true);
            }

            var genreQueryFilter = new QueryFilter(query);
            if (!isFacet)
            {
                if (termName == "_language" || isIdLookup)
                {
                    var termValueParse = terms.Split('|')[0].ToLowerInvariant();
                    if (isIdLookup)
                    {
                        termValueParse = IdHelper.NormalizeGuid(termValueParse, true);
                    }
                    genreQueryFilter =
                        new QueryFilter(
                            new TermQuery(new Term(termName.ToLowerInvariant(), termValueParse)));
                }
                else if (termName == "size" || termName == "dimensions")
                {
                    var term = new BooleanQuery();
                    term.Add(new TermQuery(new Term(termName, terms)), BooleanClause.Occur.MUST);
                    genreQueryFilter = new QueryFilter(term);
                }
                else
                {
                    genreQueryFilter =
                        new QueryFilter(
                            new TermQuery(new Term(terms.Split('|')[0].ToLowerInvariant(),
                                                   termName.ToLowerInvariant())));
                }
            }
            else
            {
                if (termName == "__created by")
                {
                    genreQueryFilter =
                        new QueryFilter(new TermQuery(new Term(termName, tempTerms)));
                }
                else
                {
                    if (Config.ExcludeContextItemFromResult)
                    {
                        if (termName == "_path")
                        {
                            var term = new BooleanQuery();
                            term.Add(new TermQuery(new Term(termName, tempTerms.ToLowerInvariant())), BooleanClause.Occur.MUST);
                            term.Add(new TermQuery(new Term(BuiltinFields.ID, tempTerms.ToLowerInvariant())),
                                     BooleanClause.Occur.MUST_NOT);
                            genreQueryFilter = new QueryFilter(term);
                        }
                        else
                        {
                            var term = new TermQuery(new Term(termName, tempTerms.ToLowerInvariant()));
                            genreQueryFilter = new QueryFilter(term);
                        }
                    }
                    else
                    {
                        var term = new TermQuery(new Term(termName, tempTerms.ToLowerInvariant()));
                        genreQueryFilter = new QueryFilter(term);
                    }
                }
            }
            if (termName == "__smallCreatedDate")
            {
                var dateStart = terms.Split('|')[0];
                var typeOfDate = terms.Split('|')[1];
                var dateEnd = new DateTime();
                if (typeOfDate == "Within a Day")
                {
                    dateEnd = DateTime.Now;
                }
                if (typeOfDate == "Within a Week")
                {
                    dateEnd = DateTime.Now.AddDays(-1);
                }
                if (typeOfDate == "Within a Month")
                {
                    dateEnd = DateTime.Now.AddDays(-7);
                }
                if (typeOfDate == "Within a Year")
                {
                    dateEnd = DateTime.Now.AddMonths(-1);
                }
                if (typeOfDate == "Older")
                {
                    dateEnd = DateTime.Now.AddYears(-1);
                }

                var boolQuery = new BooleanQuery(true);
                SearcherMethods.AddDateRangeQuery(boolQuery,
                                                  new DateRangeSearchParam.DateRangeField(termName, DateTime.Parse(dateStart),
                                                                                          dateEnd)
                                                      {InclusiveEnd = true, InclusiveStart = true}, BooleanClause.Occur.MUST);
                genreQueryFilter = new QueryFilter(boolQuery);
                if (Config.EnableBucketDebug || Constants.EnableTemporaryBucketDebug)
                {
                    Log.Info("Search Clauses Number: " + boolQuery.Clauses().Count, this);
                }
            }
            return genreQueryFilter;
        }
Example #4
0
 private void InitBlock(System.Collections.BitArray bits, QueryFilter enclosingInstance)
 {
     this.bits = bits;
     this.enclosingInstance = enclosingInstance;
 }
Example #5
0
 public AnonymousClassHitCollector(System.Collections.BitArray bits, QueryFilter enclosingInstance)
 {
     InitBlock(bits, enclosingInstance);
 }
        private List<List<FacetReturn>> GetFacets()
        {
            var ret = new List<List<FacetReturn>>();
            var facets = Context.ContentDatabase.GetItem(Constants.FacetFolder).Children;
            foreach (Item facet in facets)
            {
                if (facet.Fields["Enabled"].Value == "1")
                {
                    // pull the type off of the Sitecore item
                    string typeName = facet.Fields["Type"].Value;
                    object type = Sitecore.Reflection.ReflectionUtil.CreateObject(typeName);

                    // pull any parameters out of the Sitecore item
                    string typeParameters = facet.Fields["Parameters"].Value;
                    if (!string.IsNullOrEmpty(typeParameters))
                    {
                        Sitecore.Reflection.ReflectionUtil.SetProperties(type, typeParameters);
                    }

                    if ((type as IFacet).IsNotNull())
                    {
                        var locationOverride = GetLocationOverride();
                        using (var context = new SortableIndexSearchContext(SearchManager.GetIndex(BucketManager.GetContextIndex(Context.ContentDatabase.GetItem(locationOverride)))))
                        {

                            var query = SearchHelper.GetBaseQuery(this._searchQuery, locationOverride);
                            var queryBase = IndexSearcher.ContructQuery(query);
                            var searchBitArray = new QueryFilter(queryBase).Bits(context.Searcher.GetIndexReader());
                            var res = ((IFacet)type).Filter(queryBase, this._searchQuery, locationOverride, searchBitArray);
                            ret.Add(res);
                        }
                    }
                }
            }

            return ret;
        }
Example #7
0
		public Hashtable GetStoredUriStrings (string server, string file)
		{
			Hashtable uris = new Hashtable ();

			Term term = new Term (PropertyToFieldName (PropertyType.Keyword, "fixme:file"), file);
			LNS.QueryFilter filter = new LNS.QueryFilter (new LNS.TermQuery (term));
			
			term = new Term (PropertyToFieldName (PropertyType.Keyword, "fixme:account"), server);
			LNS.TermQuery query = new LNS.TermQuery (term);
			
			LNS.IndexSearcher searcher = LuceneCommon.GetSearcher (PrimaryStore);
			LNS.Hits hits = searcher.Search (query, filter);
			
			for (int i = 0; i < hits.Length (); i++) {
				StoredInfo info = DocumentToStoredInfo (hits.Doc (i));	
				uris.Add (info.Uri.ToString (), info.FullyIndexed);
			}

			LuceneCommon.ReleaseSearcher (searcher);
			
			return uris;
		}
        /// <summary>
        /// Gets the facets.
        /// </summary>
        /// <param name="searchQuery">The _search query.</param>
        /// <returns>The list of the facets.</returns>
        public static List<List<FacetReturn>> GetFacets(List<SearchStringModel> searchQuery)
        {
            var ret = new List<List<FacetReturn>>();
              ChildList facets = Context.ContentDatabase.GetItem(Constants.FacetFolder).Children;
              foreach (Item facet in facets)
              {
            if (facet.Fields["Enabled"].Value == "1")
            {
              dynamic type = Activator.CreateInstance(Type.GetType(facet.Fields["Type"].Value));
              if ((type as IFacet).IsNotNull())
              {
            string locationOverride = GetLocationOverride(searchQuery);
            using (
              var context =
                new SortableIndexSearchContext(
                  SearchManager.GetIndex(GetContextIndex(Context.ContentDatabase.GetItem(locationOverride)))))
            {
              DateRangeSearchParam query = SearchHelper.GetBaseQuery(searchQuery, locationOverride);
              BooleanQuery queryBase = IndexSearcher.ContructQuery(query);
              BitArray searchBitArray = new QueryFilter(queryBase).Bits(context.Searcher.GetIndexReader());
              List<FacetReturn> res = ((IFacet)type).Filter(queryBase, searchQuery, locationOverride, searchBitArray);
              ret.Add(res);
            }
              }
            }
              }

              return ret;
        }
Example #9
0
        public TopDocs Search(int pageSize)
        {
            Query query = GetQuery();

            TopDocs topDocs;
            if (Filters != null)
            {
                BooleanQuery filterQuery = new BooleanQuery();

                foreach (var id in Filters)
                {
                    filterQuery.Add(
                        new TermQuery(
                            new Term("IcaoId", id)),
                            BooleanClause.Occur.SHOULD);
                }

                var filter = new QueryFilter(filterQuery); //new SkybraryFilter(query.Filters.ToArray());
                topDocs = Searcher.Search(query, filter, pageSize);
            }
            else
            {
                topDocs = Searcher.Search(query, null, 5000);
            }

            return topDocs;
        }