BExIS.Ddm.Providers.LuceneProvider.SearchProvider.getQueryFromCriteria C# (CSharp) Method

getQueryFromCriteria() private method

private getQueryFromCriteria ( SearchCriteria searchCriteria ) : void
searchCriteria BExIS.Ddm.Model.SearchCriteria
return void
        private void getQueryFromCriteria(SearchCriteria searchCriteria)
        {
            if (searchCriteria.SearchCriteriaList.Count() > 0)
            {

                bexisSearching = new BooleanQuery();
                foreach (SearchCriterion sco in searchCriteria.SearchCriteriaList)
                {
                    if (sco.Values.Count > 0)
                    {

                        if (sco.SearchComponent.Type.Equals(SearchComponentBaseType.Category))
                        {
                            BooleanQuery bexisSearchingCategory = new BooleanQuery();
                            String fieldName = "category_" + sco.SearchComponent.Name;
                            QueryParser parser;
                            if (fieldName.ToLower().Equals("category_all"))
                            {

                                List<string> temp2 = BexisIndexSearcher.getCategoryFields().ToList();
                                temp2.AddRange(BexisIndexSearcher.getStoredFields().ToList());
                                temp2.Add("ng_all");
                                parser = new MultiFieldQueryParser(Lucene.Net.Util.Version.LUCENE_30, temp2.ToArray(), new StandardAnalyzer(Lucene.Net.Util.Version.LUCENE_30));
                            }
                            else
                            {
                                parser = new QueryParser(Lucene.Net.Util.Version.LUCENE_30, fieldName, new StandardAnalyzer(Lucene.Net.Util.Version.LUCENE_30));
                            }
                            foreach (String value in sco.Values)
                            {
                                String encodedValue = EncoderHelper.Encode(value);
                                String newString = null;
                                //string value = val.Replace(")", "").Replace("(", "");
                                char[] delimiter = new char[] { ';', ' ', ',', '!', '.' };
                                string[] parts = encodedValue.ToLower().Split(delimiter, StringSplitOptions.RemoveEmptyEntries);
                                for (int i = 0; i < parts.Length; i++)
                                {
                                    newString = newString + " " + parts[i] + "~0.6";
                                }
                                parser.PhraseSlop = 5;
                                parser.DefaultOperator = QueryParser.AND_OPERATOR;
                                string query_value = encodedValue;
                                if (encodedValue.Equals(""))
                                {
                                    query_value = "*:*";
                                }
                                Query query = parser.Parse(query_value);
                                bexisSearchingCategory.Add(query, Occur.SHOULD);
                            }
                            ((BooleanQuery)bexisSearching).Add(bexisSearchingCategory, Occur.MUST);
                        }
                        else if (sco.SearchComponent.Type.Equals(SearchComponentBaseType.Facet))
                        {
                            String fieldName = "facet_" + sco.SearchComponent.Name;
                            BooleanQuery bexisSearchingFacet = new BooleanQuery();
                            foreach (String value in sco.Values)
                            {
                                String encodedValue = value;
                                Query query = new TermQuery(new Term(fieldName, encodedValue));
                                bexisSearchingFacet.Add(query, Occur.SHOULD);
                            }
                            ((BooleanQuery)bexisSearching).Add(bexisSearchingFacet, Occur.MUST);
                        }
                        else if (sco.SearchComponent.Type.Equals(SearchComponentBaseType.Property))
                        {
                            String fieldName = "property_" + sco.SearchComponent.Name;
                            Property pp = (Property)sco.SearchComponent;
                            if (pp.UIComponent.ToLower().Equals("range"))
                            {
                                fieldName = "property_numeric_" + sco.SearchComponent.Name;
                                DateTime dd = new DateTime(Int32.Parse(sco.Values[0]), 1, 1, 1, 1, 1);
                                if (pp.Direction == Direction.increase)
                                {
                                    NumericRangeQuery<long> dateRangeQuery = NumericRangeQuery.NewLongRange(fieldName , dd.Ticks, long.MaxValue, true, true);
                                    ((BooleanQuery)bexisSearching).Add(dateRangeQuery, Occur.MUST);
                                }
                                else
                                {
                                    NumericRangeQuery<long> dateRangeQuery = NumericRangeQuery.NewLongRange(fieldName , long.MinValue, dd.Ticks, true, true);
                                    ((BooleanQuery)bexisSearching).Add(dateRangeQuery, Occur.MUST);
                                }
                            }
                            else
                            {
                                BooleanQuery bexisSearchingProperty = new BooleanQuery();
                                foreach (String value in sco.Values)
                                {

                                    if (value.ToLower().Equals("all"))
                                    {
                                        Query query = new MatchAllDocsQuery();
                                        bexisSearchingProperty.Add(query, Occur.SHOULD);
                                    }
                                    else
                                    {
                                        String encodedValue = value;
                                        if (SearchConfig.getNumericProperties().Contains(sco.SearchComponent.Name.ToLower()))
                                        {

                                        }

                                        else
                                        {
                                            Query query = new TermQuery(new Term(fieldName, encodedValue));
                                            bexisSearchingProperty.Add(query, Occur.SHOULD);
                                        }
                                    }
                                }
                                ((BooleanQuery)bexisSearching).Add(bexisSearchingProperty, Occur.MUST);

                            }
                        }
                    }
                    else
                    {
                        //do nothing yet
                    }
                }
            }
            else
            {
                QueryParser parser = new QueryParser(Lucene.Net.Util.Version.LUCENE_30, "id", new SimpleAnalyzer());
                bexisSearching = parser.Parse("*:*");
            }
        }