/// <summary>
        /// Searches for dataset nominations
        /// </summary>
        /// <param name="criteria">The criteria.</param>
        /// <param name="cancellationToken">The cancellation token.</param>
        /// <returns>The search results.</returns>
        public async Task <PagedResult <DatasetNomination> > SearchNominations(NominationSearch criteria, CancellationToken cancellationToken)
        {
            cancellationToken.ThrowIfCancellationRequested();
            var parameters = new SearchParameters
            {
                //OrderBy = new[] {(criteria.SortOrder == SortOrder.Modified ? "modified desc" : "name asc")},
                OrderBy = new[] { "timeStamp desc" },
                Top     = PageHelper.PageSize,
                Skip    = criteria.Page * PageHelper.PageSize,
                IncludeTotalResultCount = true,
                ScoringProfile          = "textBoostScoring",
                Facets = criteria.Facets.Keys.ToList(),
                Filter = CreateFilterString(criteria)
            };

            var searchTerm = string.IsNullOrWhiteSpace(criteria.Terms) ? "*" : criteria.Terms;
            var results    = await Client.Documents.SearchAsync <DatasetNominationStorageItem>(searchTerm, parameters, null, cancellationToken);

            return(new PagedResult <DatasetNomination>
            {
                PageCount = PageHelper.CalculateNumberOfPages(results.Count),
                Value = (from item in results.Results
                         let doc = item.Document
                                   select doc.ToDatasetNomination()).ToList()
            });
        }
        private static StringBuilder AppendDomainFilterString(NominationSearch criteria, StringBuilder sb)
        {
            var domainValues = criteria.Facets[FacetKey.DomainId].Where(t => !string.IsNullOrEmpty(t)).ToList();

            if (!domainValues.Any())
            {
                return(sb);
            }

            sb.Append($" ( ");
            bool needsOr = false;

            foreach (var value in domainValues)
            {
                if (!needsOr)
                {
                    needsOr = true;
                }
                else
                {
                    sb.Append($" or ");
                }

                sb.Append($"{FacetKey.DomainId} eq '{value}'");
            }
            sb.Append($" ) ");

            return(sb);
        }
        public async Task <IActionResult> Search([FromBody] NominationSearch criteria, CancellationToken cancellationToken)
        {
            cancellationToken.ThrowIfCancellationRequested();
            criteria.Page = Math.Max(0, criteria.Page - 1);
            var response = await UserDataSearch.SearchNominations(criteria, cancellationToken).ConfigureAwait(false);

            return(Ok(response));
        }
        private static string CreateFilterString(NominationSearch criteria)
        {
            StringBuilder sb = new StringBuilder();

            // Convert the facets into OData formatted query members
            foreach (var facetKey in criteria.Facets.Keys.Where(t => !string.IsNullOrEmpty(t)))
            {
                var key = UpdateFacetKey(facetKey);

                if (sb.Length > 0)
                {
                    sb.Append(" and ");
                }

                if (key == FacetKey.DomainId)
                {
                    sb = AppendDomainFilterString(criteria, sb);
                }
                else if (key == FacetKey.LicenseId)
                {
                    sb = AppendLicenseFilterString(criteria, sb);
                }
                else
                {
                    bool needsOr = false;
                    foreach (var value in criteria.Facets[key].Where(t => !string.IsNullOrEmpty(t)))
                    {
                        if (!needsOr)
                        {
                            needsOr = true;
                        }
                        else
                        {
                            sb.Append($" and ");
                        }

                        sb.Append($"{key}/any(t:");
                        sb.Append($"t eq '{value.Replace("'", "''")}'");
                        sb.Append(")");
                    }
                }
            }

            return(sb.ToString());
        }
        private static StringBuilder AppendLicenseFilterString(NominationSearch criteria, StringBuilder sb)
        {
            bool needsOr = false;

            foreach (var value in criteria.Facets[FacetKey.LicenseId].Where(t => !string.IsNullOrEmpty(t)))
            {
                if (!needsOr)
                {
                    needsOr = true;
                }
                else
                {
                    sb.Append($" and ");
                }

                sb.Append($"{FacetKey.LicenseId} eq '{value}'");
            }

            return(sb);
        }