예제 #1
0
        public async Task <CustomSearchResult <T> > CustomQueryAsync <T>(RequestBase query, CultureInfo culture, CancellationToken cancellationToken, string indexName = null)
        {
            if (query == null)
            {
                return(new CustomSearchResult <T>());
            }

            EsCustomRootObject <T> rawResults = await GetRawResultsAsync <EsCustomRootObject <T> >(query, Language.GetLanguageCode(culture), cancellationToken, indexName);

            if (rawResults == null)
            {
                return(new CustomSearchResult <T>());
            }

            if (rawResults.Hits?.HitArray == null || rawResults.Hits.HitArray.Length == 0)
            {
                return(new CustomSearchResult <T>());
            }

            var searchResult = new SearchResult
            {
                Query     = query.ToString(Formatting.Indented),
                TotalHits = rawResults.Hits.Total,
                Took      = rawResults.Took
            };

            IEnumerable <CustomSearchHit <T> > searchHits = rawResults.Hits.HitArray.Select(h => new CustomSearchHit <T>(h.Source, h.Score, h.Highlight));
            var customSearchResult = new CustomSearchResult <T>(searchResult, searchHits);

            SetupFacets(rawResults, customSearchResult);

            return(customSearchResult);
        }
예제 #2
0
        public CustomSearchResult SearchProducts(IContent currentContent, FilterOptionViewModel filterOptions)
        {
            if (filterOptions == null)
            {
                return(new CustomSearchResult
                {
                    FacetGroups = new List <FacetGroupOption>(),
                    ProductViewModels = new List <ProductViewModel>()
                });
            }
            var query         = BuildSearchQuery(currentContent, filterOptions);
            var searchResults = query.GetContentResult();

            CustomSearchResult returnedResults = new CustomSearchResult
            {
                FacetGroups       = BuildFacetGroupList(currentContent, filterOptions),
                ProductViewModels = CreateProductViewModels(searchResults),
                TotalCount        = searchResults.TotalMatching
            };

            // Products Market Filtering
            var curentMarketCode = _currentMarket.GetCurrentMarket().MarketId;

            returnedResults.ProductViewModels = returnedResults.ProductViewModels.Where(product => !product.MarketFilter.Contains(curentMarketCode.Value));
            return(returnedResults);
        }
예제 #3
0
        public CustomSearchResult <T> CustomQuery <T>(RequestBase query, CultureInfo culture, string indexName = null)
        {
            if (query == null)
            {
                return(new CustomSearchResult <T>());
            }

            RawResults <EsCustomRootObject <T> > rawResults = GetRawResults <EsCustomRootObject <T> >(query, Language.GetLanguageCode(culture), indexName);

            if (rawResults?.RootObject == null)
            {
                return(new CustomSearchResult <T>());
            }

            var searchResult = new CustomSearchResult <T>
            {
                Query = query.ToString(Formatting.Indented)
            };

            if (rawResults.RootObject.Hits?.HitArray != null && rawResults.RootObject.Hits.HitArray.Length > 0)
            {
                searchResult.Hits      = rawResults.RootObject.Hits.HitArray.Select(h => new CustomSearchHit <T>(h.Source, h.Score, h.Highlight));
                searchResult.TotalHits = rawResults.RootObject.Hits.Total;
                searchResult.Took      = rawResults.RootObject.Took;
            }

            SetupFacets(rawResults.RootObject, searchResult);

            return(searchResult);
        }
예제 #4
0
 public RequestViewModel(CustomSearchResult drcTable)
 {
     ID                  = drcTable.ID;
     OA                  = drcTable.OA;
     CaseID              = drcTable.CaseID;
     EmployeeID          = drcTable.EmployeeID;
     EmployeeLastName    = drcTable.EmployeeLastName;
     EmployeeFirstName   = drcTable.EmployeeFirstName;
     Position            = drcTable.Position;
     Grade               = drcTable.Grade;
     EmployeePhone       = drcTable.EmployeePhone;
     EmployeePhoneExt    = drcTable.EmployeePhoneExt;
     EmployeeEmail       = drcTable.EmployeeEmail;
     Disability          = drcTable.Disability;
     SupervisorLastName  = drcTable.SupervisorLastName;
     SupervisorFirstName = drcTable.SupervisorFirstName;
     SupervisorEmail     = drcTable.SupervisorEmail;
     SupervisorPhone     = drcTable.SupervisorPhone;
     SupervisorPhoneExt  = drcTable.SupervisorPhoneExt;
     Description         = drcTable.Description;
     DateRequestReceived = drcTable.DateRequestReceived;
     COWADate            = drcTable.COWADate;
     QuarterReceived     = drcTable.QuarterReceived;
     DateCompleted       = drcTable.DateCompleted;
     DateFulfilled       = drcTable.DateFulfilled;
     DRCRequestType      = drcTable.DRCRequestType;
     DRCStatus           = drcTable.DRCStatus;
     OC                  = drcTable.OC;
     Source              = drcTable.Source;
     RequestedMD715      = drcTable.RequestedMD715;
     EndMD715            = drcTable.EndMD715;
     AnalystAssigned     = drcTable.AnalystAssigned;
     TFToday             = (int)drcTable.TFToday;
     TFReportDate        = drcTable.TFReportDate;
     ReportInOut         = drcTable.ReportInOut;
     Notes               = drcTable.Notes;
     Comments            = drcTable.Comments;
     deleted             = (bool)drcTable.deleted;
     CreatedBy           = drcTable.CreatedBy;
     Purchasing          = drcTable.Purchasing;
     PRNumber            = drcTable.PRNumber;
     Amount              = drcTable.Amount;
     UpdatedBy           = drcTable.UpdatedBy;
     CreatedDate         = drcTable.CreatedDate;
     UpdatedDate         = drcTable.UpdatedDate;
     ProvidedAccom       = drcTable.ProvidedAccom;
 }
예제 #5
0
        public CustomSearchResult Search(IContent currentContent, FilterOptionViewModel filterOptions)
        {
            var returnResult = new CustomSearchResult();
            var searchClient = SearchClient.Instance.Search <FashionProduct>();

            var pageSize = filterOptions.PageSize > 0 ? filterOptions.PageSize : _defaultPageSize;
            var query    = searchClient.For(filterOptions.Q)
                           .InAllField()
                           .TermsFacetFor(x => x.Gender())
                           .TermsFacetFor(x => x.CategoryCode())
                           .TermsFacetFor(x => x.Brand)
                           .TermsFacetFor(x => x.AvailableColors)
                           .PublishedInCurrentLanguage()
                           .Skip(pageSize * (filterOptions.Page - 1))
                           .Take(pageSize);

            if (currentContent != null && currentContent.GetOriginalType() != typeof(SearchPage))
            {
                query = query.Filter(x => x.Ancestors().Match(currentContent.ContentLink.ToReferenceWithoutVersion().ToString()));
            }

            //Pre-checked Facets
            foreach (var filter in filterOptions.FacetGroups)
            {
                var filterValue = filter.Facets.FirstOrDefault().Key;
                switch (filter.GroupFieldName)
                {
                case SearchFilterField.Color:
                    query = query.Filter(x => x.AvailableColors.MatchCaseInsensitive(filterValue));
                    break;

                case SearchFilterField.Brand:
                    query = query.Filter(x => x.Brand.MatchCaseInsensitive(filterValue));
                    break;

                case SearchFilterField.Gender:
                    query = query.Filter(x => x.Gender().MatchCaseInsensitive(filterValue));
                    break;

                case SearchFilterField.Category:
                    query = query.Filter(x => x.CategoryCode().MatchCaseInsensitive(filterValue));
                    break;
                }
            }

            //Sorting
            var sortOrder = GetSortOrder().FirstOrDefault(x => x.Name.ToString() == filterOptions.Sort) ?? GetSortOrder().First();

            switch (sortOrder.Name)
            {
            case ProductSortOrder.NewestFirst:
                query = query.OrderByDescending(x => x.Created);
                break;

            case ProductSortOrder.PriceAsc:
                query = query.OrderBy(x => x.DiscountPrice().Amount);
                break;
            }

            var results      = query.GetContentResult();
            var returnFacets = new List <FacetGroupOption>();

            foreach (var findFacet in results.Facets)
            {
                var termFacet = findFacet as TermsFacet;
                if (termFacet != null)
                {
                    var facetGroupOption = new FacetGroupOption()
                    {
                        GroupFieldName = termFacet.Name,
                        GroupName      = GetFriendlyFacetName(termFacet.Name),
                        Facets         = termFacet.Terms.Select(x => new FacetOption()
                        {
                            Name     = x.Term,
                            Count    = x.Count,
                            Key      = x.Term,
                            Selected = IsSelectedFacet(termFacet.Name, x.Term, filterOptions)
                        }).ToList()
                    };

                    returnFacets.Add(facetGroupOption);
                }
            }

            returnResult.FacetGroups       = returnFacets;
            returnResult.ProductViewModels = CreateProductViewModels(results);
            returnResult.TotalCount        = results.SearchResult.TotalMatching;
            return(returnResult);
        }