@bridgeline-digital/hawksearch-handlebars-ui 1.0.0-beta.0

package/src/services/search.service.ts

@@ -0,0 +1,754 @@
+import { cloneDeep } from 'lodash';
+import {
+    FacetType,
+    FacetValue,
+    FacetValueColor,
+    HawksearchGlobal,
+    HawksearchState,
+    ModifiedQueryData,
+    QuerySuggestionsData,
+    RawFacet,
+    RawFacetValue,
+    RawSearchRequest,
+    RawSearchResponse,
+    RawSearchSelection,
+    SearchRequest,
+    SearchResponse,
+    SelectedFacet,
+    SelectedFacets
+} from '../models';
+import { BaseService } from './base.service';
+import { trackingService } from './tracking.service';
+
+declare let Hawksearch: HawksearchGlobal;
+
+export class SearchService extends BaseService {
+    protected baseUrl = Hawksearch.config.endpoints?.search || 'https://searchapi-dev.hawksearch.net/api/v2';
+
+    // #region Search Operations
+
+    async search(searchRequest: SearchRequest): Promise<SearchResponse> {
+        const searchReults = await this.executeSearch(searchRequest, true, false);
+
+        this.bindComponents(searchReults);
+
+        return searchReults;
+    }
+
+    async query(query?: string, disableSpellcheck = false): Promise<SearchResponse> {
+        const request: SearchRequest = {
+            disableSpellcheck: !!disableSpellcheck || undefined,
+            query: query,
+            newRequest: true
+        };
+
+        const searchResponse = await this.executeSearch(request, true, false);
+
+        this.bindComponents(searchResponse);
+
+        return searchResponse;
+    }
+
+    async addFacetValue(field: string, value: string): Promise<SearchResponse> {
+        this.ensureSearchRequest();
+
+        const searchRequest = cloneDeep(Hawksearch.searchRequest!);
+
+        searchRequest.newRequest = false;
+        searchRequest.page = undefined;
+
+        if (!searchRequest.facets) {
+            searchRequest.facets = {};
+        }
+
+        this.clearExistingFacetValue(searchRequest, field, value);
+
+        searchRequest.facets[field] = [...(searchRequest.facets[field]?.filter((v) => v !== value) ?? []), value];
+
+        const searchResponse = await this.executeSearch(searchRequest, false);
+
+        this.bindFacetsListComponent(searchResponse);
+        this.bindPaginationComponent(searchResponse);
+        this.bindSelectedFacetsComponent(searchResponse);
+        this.bindTabsComponent(searchResponse);
+
+        return searchResponse;
+    }
+
+    async removeFacetValue(field: string, value: string): Promise<SearchResponse> {
+        this.ensureSearchRequest();
+
+        if (field === 'searchWithin') {
+            return await this.searchWithin('');
+        }
+
+        const searchRequest = cloneDeep(Hawksearch.searchRequest!);
+
+        searchRequest.newRequest = false;
+        searchRequest.page = undefined;
+
+        this.clearExistingFacetValue(searchRequest, field, value);
+
+        const searchResponse = await this.executeSearch(searchRequest, false);
+
+        this.bindFacetsListComponent(searchResponse);
+        this.bindPaginationComponent(searchResponse);
+        this.bindSelectedFacetsComponent(searchResponse);
+        this.bindTabsComponent(searchResponse);
+
+        return searchResponse;
+    }
+
+    includeFacetValue(field: string, value: string): Promise<SearchResponse> {
+        const excludedValue = `@${value}`;
+
+        return this.removeFacetValue(field, excludedValue);
+    }
+
+    async excludeFacetValue(field: string, value: string): Promise<SearchResponse> {
+        this.ensureSearchRequest();
+
+        const excludedValue = `@${value}`;
+        const searchRequest = cloneDeep(Hawksearch.searchRequest!);
+
+        searchRequest.newRequest = false;
+        searchRequest.page = undefined;
+
+        if (!searchRequest.facets) {
+            searchRequest.facets = {};
+        }
+
+        this.clearExistingFacetValue(searchRequest, field, value);
+
+        searchRequest.facets = {
+            ...searchRequest.facets,
+            [field]: [...(searchRequest.facets[field] ?? []), excludedValue]
+        };
+
+        const searchResponse = await this.executeSearch(searchRequest, false);
+
+        this.bindFacetsListComponent(searchResponse);
+        this.bindPaginationComponent(searchResponse);
+        this.bindSelectedFacetsComponent(searchResponse);
+        this.bindTabsComponent(searchResponse);
+
+        return searchResponse;
+    }
+
+    private clearExistingFacetValue(searchRequest: SearchRequest, field: string, value: string): void {
+        value = value.replace(/^@/, '');
+
+        const excludedValue = `@${value}`;
+
+        if (!searchRequest.facets) {
+            searchRequest.facets = {};
+        }
+
+        searchRequest.facets = {
+            ...searchRequest.facets,
+            [field]: [...(searchRequest.facets[field]?.filter((v) => v !== value && v !== excludedValue) ?? [])]
+        };
+
+        if (!searchRequest.facets[field]?.length) {
+            delete searchRequest.facets[field];
+        }
+    }
+
+    async setFacetValue(field: string, value: string): Promise<SearchResponse> {
+        this.ensureSearchRequest();
+
+        const request = cloneDeep(Hawksearch.searchRequest!);
+
+        request.newRequest = false;
+        request.page = undefined;
+
+        if (!request.facets) {
+            request.facets = {};
+        }
+
+        request.facets[field] = [value];
+
+        const searchResponse = await this.executeSearch(request, false);
+
+        this.bindFacetsListComponent(searchResponse);
+        this.bindPaginationComponent(searchResponse);
+        this.bindSelectedFacetsComponent(searchResponse);
+        this.bindTabsComponent(searchResponse);
+
+        return searchResponse;
+    }
+
+    async modifySearch(query: string | undefined, facets: SelectedFacets | undefined): Promise<SearchResponse> {
+        this.ensureSearchRequest();
+
+        const request = cloneDeep(Hawksearch.searchRequest!);
+
+        request.query = query;
+        request.facets = facets;
+        request.newRequest = false;
+        request.page = undefined;
+
+        const searchResponse = await this.executeSearch(request, false);
+
+        this.bindFacetsListComponent(searchResponse);
+        this.bindPaginationComponent(searchResponse);
+        this.bindSelectedFacetsComponent(searchResponse);
+        this.bindTabsComponent(searchResponse);
+
+        return searchResponse;
+    }
+
+    async searchWithin(value: string): Promise<SearchResponse> {
+        this.ensureSearchRequest();
+
+        const request = cloneDeep(Hawksearch.searchRequest!);
+
+        request.newRequest = false;
+        request.page = undefined;
+        request.searchWithin = value || undefined;
+
+        const searchResponse = await this.executeSearch(request, false);
+
+        this.bindFacetsListComponent(searchResponse);
+        this.bindPaginationComponent(searchResponse);
+        this.bindSelectedFacetsComponent(searchResponse);
+        this.bindTabsComponent(searchResponse);
+
+        return searchResponse;
+    }
+
+    async selectTab(value?: string): Promise<SearchResponse> {
+        this.ensureSearchRequest();
+
+        const request = cloneDeep(Hawksearch.searchRequest!);
+
+        request.newRequest = false;
+        request.page = undefined;
+
+        if (!request.facets) {
+            request.facets = {};
+        }
+
+        const field = Hawksearch.searchResponse?.facets?.find((f) => f.type === 'tabs')?.field;
+
+        if (field) {
+            if (value) {
+                request.facets[field] = [value];
+            } else {
+                delete request.facets[field];
+            }
+        }
+
+        const searchResponse = await this.executeSearch(request, false);
+
+        this.bindFacetsListComponent(searchResponse);
+        this.bindPaginationComponent(searchResponse);
+        this.bindSelectedFacetsComponent(searchResponse);
+        this.bindTabsComponent(searchResponse);
+
+        return searchResponse;
+    }
+
+    async paginate(page: number): Promise<SearchResponse> {
+        this.ensureSearchRequest();
+
+        const request = cloneDeep(Hawksearch.searchRequest!);
+
+        request.newRequest = false;
+        request.page = page;
+
+        const searchResponse = await this.executeSearch(request, false);
+
+        this.bindPaginationComponent(searchResponse);
+
+        return searchResponse;
+    }
+
+    async setPageSize(pageSize: number): Promise<SearchResponse> {
+        this.ensureSearchRequest();
+
+        const request = cloneDeep(Hawksearch.searchRequest!);
+
+        request.newRequest = false;
+        request.pageSize = pageSize;
+
+        const searchResponse = await this.executeSearch(request, false);
+
+        this.bindPageSizeComponent(searchResponse);
+        this.bindPaginationComponent(searchResponse);
+
+        return searchResponse;
+    }
+
+    async sort(value?: string): Promise<SearchResponse> {
+        this.ensureSearchRequest();
+
+        const request = cloneDeep(Hawksearch.searchRequest!);
+
+        request.newRequest = false;
+        request.page = 1;
+        request.sort = value;
+
+        const searchResponse = await this.executeSearch(request, false);
+
+        this.bindPaginationComponent(searchResponse);
+        this.bindSortingComponent(searchResponse);
+
+        return searchResponse;
+    }
+
+    private executeSearch(searchRequest: SearchRequest, newSearch: boolean, executeDefaultBindings = true): Promise<SearchResponse> {
+        Hawksearch.searchRequest = searchRequest;
+
+        const rawRequest: RawSearchRequest = {
+            ClientData: {
+                UserAgent: window.navigator.userAgent,
+                VisitorId: this.getVisitorId(),
+                VisitId: this.getVisitId()
+            },
+            ClientGuid: Hawksearch.config.clientId,
+            IgnoreSpellcheck: searchRequest.disableSpellcheck,
+            Keyword: searchRequest.query,
+            FacetSelections: searchRequest.facets,
+            MaxPerPage: searchRequest.pageSize,
+            PageNo: searchRequest.page,
+            SearchWithin: searchRequest.searchWithin,
+            SortBy: searchRequest.sort
+        };
+
+        return this.httpPost<RawSearchResponse>('/search', rawRequest).then((rawSearchResponse) => {
+            const searchResponse = this.convertSearchResponse(searchRequest, rawSearchResponse);
+
+            Hawksearch.searchResponse = searchResponse;
+
+            trackingService.trackSearch(searchRequest.query, newSearch);
+
+            this.setQueryString();
+
+            const newEvent = new CustomEvent('hawksearch:search-completed', {
+                detail: searchResponse
+            });
+
+            dispatchEvent(newEvent);
+
+            if (executeDefaultBindings) {
+                this.bindModifiedQueryComponent(searchResponse);
+                this.bindSearchComponent(searchResponse);
+                this.bindSearchResultsListComponent(searchResponse);
+                this.bindQuerySuggestionsComponent(searchResponse);
+            }
+
+            if (newSearch && searchResponse.redirect) {
+                window.open(searchResponse.redirect.url, searchResponse.redirect.target ?? '_self');
+            }
+
+            return searchResponse;
+        });
+    }
+
+    private ensureSearchRequest(): void {
+        if (!Hawksearch.searchRequest) {
+            throw new Error('You cannot refine search results until an initial search has been executed');
+        }
+    }
+
+    // #endregion Search Operations
+
+    // #region Model Binding
+
+    private convertSearchResponse(searchRequest: SearchRequest, searchResponse: RawSearchResponse): SearchResponse {
+        const getFacetType = (facet: RawFacet): FacetType => {
+            if (facet.FieldType === 'tab') {
+                return 'tabs';
+            }
+
+            switch (facet.FacetType) {
+                case 'nestedcheckbox':
+                    return 'checkbox';
+                case 'slider':
+                    return 'range-slider';
+                case 'swatch':
+                    return 'color';
+                default:
+                    return facet.FacetType as FacetType;
+            }
+        };
+
+        const getFacetValueColor = (facet: RawFacet, value: RawFacetValue): FacetValueColor | undefined => {
+            const swatchValue = facet.SwatchData?.find((v) => v.Value.toLowerCase() === value.Value.toLowerCase());
+
+            if (!swatchValue) {
+                return undefined;
+            }
+
+            return {
+                name: swatchValue.Value,
+                hex: swatchValue.Color || swatchValue.Value,
+                imageUrl: this.getUrl(Hawksearch.config.urlPrefixes?.assets, swatchValue.AssetUrl || swatchValue.AssetName)
+            };
+        };
+
+        const getFacetValues = (
+            facet: RawFacet,
+            values: Array<RawFacetValue> | undefined,
+            selection: RawSearchSelection | undefined
+        ): Array<FacetValue> | undefined => {
+            return values?.map((v) => ({
+                title: v.Label,
+                value: v.Value,
+                color: getFacetValueColor(facet, v),
+                count: v.Count,
+                level: v.Level,
+                selected: v.Selected,
+                excluded: selection?.Items?.some((s) => s.Value === `@${v.Value}`),
+                children: getFacetValues(facet, v.Children, selection)
+            }));
+        };
+
+        const getSearchWithinSelectedFacets = (): Array<SelectedFacet> => {
+            const facetName = 'searchWithin';
+            const facet = searchResponse.Facets?.find((f) => f.Field === facetName);
+
+            if (!searchRequest.searchWithin || !facet) {
+                return [];
+            }
+
+            return [
+                {
+                    field: facetName,
+                    title: facet.Name,
+                    values: [
+                        {
+                            title: searchRequest.searchWithin,
+                            value: searchRequest.searchWithin,
+                            excluded: false
+                        }
+                    ]
+                }
+            ];
+        };
+
+        return {
+            facets: searchResponse.Facets?.map((f) => ({
+                id: f.FacetId,
+                type: getFacetType(f),
+                title: f.Name,
+                field: f.ParamName || f.Field || undefined,
+                collapsible: f.IsCollapsible ?? false,
+                collapsed: f.IsCollapsedDefault,
+                rangeMin: getFacetType(f) === 'range-slider' && f.Values?.length ? parseFloat(f.Values[0].RangeMin ?? '0') : undefined,
+                rangeMax: getFacetType(f) === 'range-slider' && f.Values?.length ? parseFloat(f.Values[0].RangeMax ?? '0') : undefined,
+                rangeStart: getFacetType(f) === 'range-slider' && f.Values?.length ? parseFloat(f.Values[0].RangeStart ?? '0') : undefined,
+                rangeEnd: getFacetType(f) === 'range-slider' && f.Values?.length ? parseFloat(f.Values[0].RangeEnd ?? '0') : undefined,
+                searchable: f.IsSearch,
+                searchWithin: searchRequest.searchWithin,
+                tooltip: this.stripHtml(f.Tooltip ?? '') || undefined,
+                truncateThreshold: parseFloat(f.TruncateThreshold as any) || undefined,
+                values: getFacetValues(f, f.Values, searchResponse.Selections?.[f.ParamName || f.Field])
+            })),
+            modifiedQuery: searchResponse.AdjustedKeyword,
+            pagination: searchResponse.Pagination
+                ? {
+                      page: searchResponse.Pagination.CurrentPage,
+                      pageSize: searchResponse.Pagination.MaxPerPage,
+                      totalPages: searchResponse.Pagination.NofPages,
+                      totalResults: searchResponse.Pagination.NofResults,
+                      maxPageLinks: searchResponse.Pagination.NumberOfPageLinks > 0 ? searchResponse.Pagination.NumberOfPageLinks : undefined,
+                      displayFirstLink: searchResponse.Pagination.IsShowFirstLink,
+                      displayLastLink: searchResponse.Pagination.IsShowLastLink,
+                      options:
+                          searchResponse.Pagination.Items.map((i) => ({
+                              title: i.Label,
+                              pageSize: i.PageSize,
+                              selected: i.Selected,
+                              default: i.Default
+                          })) ?? []
+                  }
+                : undefined,
+            query: searchResponse.Keyword,
+            querySuggestions: searchResponse.DidYouMean,
+            redirect: searchResponse.Redirect
+                ? {
+                      url: searchResponse.Redirect.Location,
+                      target: searchResponse.Redirect.Target
+                  }
+                : undefined,
+            results: searchResponse.Results?.map((r) => ({
+                id: r.DocId,
+                pinned: r.IsPin ?? false,
+                visible: r.IsVisible ?? true,
+                score: r.Score,
+                type: r.Document?.['contenttype']?.[0] === 'Content' ? 'content' : 'product',
+                imageUrl: this.getUrl(Hawksearch.config.urlPrefixes?.content, this.getString(r.Document?.[this.fieldMappings.imageUrl])),
+                title: this.getString(r.Document?.[this.fieldMappings.title])!,
+                url: this.getUrl(Hawksearch.config.urlPrefixes?.content, this.getString(r.Document?.[this.fieldMappings.url]))!,
+                price: this.getNumber(r.Document?.[this.fieldMappings.price]),
+                salePrice: this.getNumber(r.Document?.[this.fieldMappings.salePrice]),
+                attributes: r.Document
+            })),
+            selectedFacets: [
+                ...Object.keys(searchResponse.Selections ?? []).map((field) => {
+                    const selection = searchResponse.Selections![field];
+                    const excludedRegex = new RegExp('^@');
+
+                    return {
+                        field: field,
+                        title: selection.Label,
+                        values: selection.Items.map((i) => ({
+                            title: i.Label.replace(excludedRegex, ''),
+                            value: i.Value,
+                            excluded: excludedRegex.test(i.Value)
+                        }))
+                    };
+                }),
+                ...getSearchWithinSelectedFacets()
+            ],
+            success: searchResponse.Success,
+            sorting: {
+                value: searchResponse.Sorting?.Value,
+                options:
+                    searchResponse.Sorting?.Items.map((i) => ({
+                        title: i.Label,
+                        value: i.Value,
+                        selected: i.Selected,
+                        default: i.IsDefault
+                    })) ?? []
+            },
+            trackingId: searchResponse.TrackingId
+        };
+    }
+
+    private getString(values: Array<string> | undefined, defaultValue?: string): string | undefined {
+        return values?.[0] ?? defaultValue;
+    }
+
+    private getNumber(values: Array<string> | undefined, defaultValue?: number): number | undefined {
+        const string = this.getString(values);
+        let value = string ? parseFloat(string) : undefined;
+
+        if (value !== undefined && isNaN(value)) {
+            value = undefined;
+        }
+
+        return value ?? defaultValue;
+    }
+
+    private getUrl(prefix: string | undefined, url: string | undefined): string | undefined {
+        if (!url) {
+            return undefined;
+        }
+
+        if (!!prefix && !/^https?:\/\//.test(url)) {
+            return `${prefix}/${url.replace(/^\/+/, '')}`;
+        }
+
+        return url;
+    }
+
+    // #endregion Model Binding
+
+    // #region Events
+
+    bindComponents(searchResponse: SearchResponse): void {
+        this.bindSearchResultsComponent(searchResponse); // This needs to be first since it contains the other components
+        this.bindFacetsListComponent(searchResponse);
+        this.bindModifiedQueryComponent(searchResponse);
+        this.bindPageSizeComponent(searchResponse);
+        this.bindPaginationComponent(searchResponse);
+        this.bindQuerySuggestionsComponent(searchResponse);
+        this.bindSearchComponent(searchResponse);
+        this.bindSearchResultsListComponent(searchResponse);
+        this.bindSelectedFacetsComponent(searchResponse);
+        this.bindSortingComponent(searchResponse);
+        this.bindTabsComponent(searchResponse);
+    }
+
+    bindFacetsListComponent(searchResponse: SearchResponse | undefined): void {
+        this.triggerEvent('hawksearch:bind-facets-list', searchResponse?.facets);
+    }
+
+    bindModifiedQueryComponent(searchResponse: SearchResponse | undefined): void {
+        const data: ModifiedQueryData = {
+            display: !!searchResponse?.query && !!searchResponse?.modifiedQuery && Hawksearch.searchRequest!.newRequest,
+            query: searchResponse?.query,
+            modifiedQuery: searchResponse?.modifiedQuery
+        };
+
+        this.triggerEvent('hawksearch:bind-modified-query', data);
+    }
+
+    bindPageSizeComponent(searchResponse: SearchResponse | undefined): void {
+        this.triggerEvent('hawksearch:bind-page-size', searchResponse?.pagination?.options);
+    }
+
+    bindPaginationComponent(searchResponse: SearchResponse | undefined): void {
+        this.triggerEvent('hawksearch:bind-pagination', searchResponse?.pagination);
+    }
+
+    bindQuerySuggestionsComponent(searchResponse: SearchResponse | undefined): void {
+        const data: QuerySuggestionsData = {
+            display: !!searchResponse?.querySuggestions?.length && Hawksearch.searchRequest!.newRequest,
+            querySuggestions: searchResponse?.querySuggestions
+        };
+
+        this.triggerEvent('hawksearch:bind-query-suggestions', data);
+    }
+
+    bindSortingComponent(searchResponse: SearchResponse | undefined): void {
+        this.triggerEvent('hawksearch:bind-sorting', searchResponse?.sorting);
+    }
+
+    bindSearchComponent(searchResponse: SearchResponse | undefined): void {
+        this.triggerEvent('hawksearch:bind-search', searchResponse);
+    }
+
+    bindSearchResultsComponent(searchResponse: SearchResponse | undefined): void {
+        this.triggerEvent('hawksearch:bind-search-results', searchResponse);
+    }
+
+    bindSearchResultsListComponent(searchResponse: SearchResponse | undefined): void {
+        this.triggerEvent('hawksearch:bind-search-results-list', searchResponse?.results);
+    }
+
+    bindSelectedFacetsComponent(searchResponse: SearchResponse | undefined): void {
+        this.triggerEvent('hawksearch:bind-selected-facets', searchResponse?.selectedFacets);
+    }
+
+    bindTabsComponent(searchResponse: SearchResponse | undefined): void {
+        this.triggerEvent(
+            'hawksearch:bind-tabs',
+            searchResponse?.facets?.find((f) => f.type === 'tabs')
+        );
+    }
+
+    private triggerEvent<T>(name: string, data: T): void {
+        const event = new CustomEvent(name, { detail: data });
+
+        dispatchEvent(event);
+    }
+
+    // #endregion Events
+
+    // #region QueryString
+
+    getRequestFromUrl(): SearchRequest {
+        const url = new URL(window.location.href);
+        const facets: SelectedFacets = {};
+        const facetRegex = new RegExp(`^${this.queryStringParams.facet}-`);
+
+        for (const key of Array.from(url.searchParams.keys()).filter((k) => facetRegex.test(k))) {
+            const field = key.replace(facetRegex, '');
+
+            facets[field] = url.searchParams.getAll(key);
+        }
+
+        return {
+            disableSpellcheck: this.getBooleanParameter(url.searchParams.get(this.queryStringParams.disableSpellcheck)),
+            facets: facets,
+            newRequest: true,
+            pageSize: this.getPositiveIntegerParameter(url.searchParams.get(this.queryStringParams.pageSize)),
+            page: this.getPositiveIntegerParameter(url.searchParams.get(this.queryStringParams.page)),
+            query: this.getStringParameter(url.searchParams.get(this.queryStringParams.query)),
+            searchWithin: this.getStringParameter(url.searchParams.get(this.queryStringParams.searchWithin)),
+            sort: this.getStringParameter(url.searchParams.get(this.queryStringParams.sort))
+        };
+    }
+
+    private setQueryString(): void {
+        if (!Hawksearch.searchRequest) {
+            return;
+        }
+
+        const request = Hawksearch.searchRequest;
+        const url = new URL(window.location.href);
+
+        url.searchParams.delete(this.queryStringParams.query);
+
+        if (request.query) {
+            url.searchParams.set(this.queryStringParams.query, request.query);
+        }
+
+        for (const key of url.searchParams.keys()) {
+            if (key.startsWith(`${this.queryStringParams.facet}-`)) {
+                url.searchParams.delete(key);
+            }
+        }
+
+        if (request.disableSpellcheck) {
+            url.searchParams.set(this.queryStringParams.disableSpellcheck, request.disableSpellcheck.toString());
+        }
+
+        if (request.facets) {
+            Object.keys(request.facets).forEach((field) => {
+                const values = request.facets![field];
+
+                values?.forEach((value) => url.searchParams.append(`${this.queryStringParams.facet}-${field}`, value));
+            });
+        }
+
+        url.searchParams.delete(this.queryStringParams.searchWithin);
+
+        if (request.searchWithin) {
+            url.searchParams.set(this.queryStringParams.searchWithin, request.searchWithin);
+        }
+
+        url.searchParams.delete(this.queryStringParams.sort);
+
+        if (request.sort) {
+            url.searchParams.set(this.queryStringParams.sort, request.sort);
+        }
+
+        url.searchParams.delete(this.queryStringParams.pageSize);
+
+        if (request.pageSize) {
+            url.searchParams.set(this.queryStringParams.pageSize, request.pageSize.toString());
+        }
+
+        url.searchParams.delete(this.queryStringParams.page);
+
+        if (request.page) {
+            url.searchParams.set(this.queryStringParams.page, request.page.toString());
+        }
+
+        const state: HawksearchState = {
+            searchRequest: Hawksearch.searchRequest,
+            searchResponse: Hawksearch.searchResponse!
+        };
+
+        if (url.toString() === window.location.href) {
+            window.history.replaceState(state, '');
+        } else {
+            window.history.pushState(state, '', url.toString());
+        }
+    }
+
+    private getBooleanParameter(input: string | null): boolean | undefined {
+        if (input === null) {
+            return undefined;
+        }
+
+        return input === 'true';
+    }
+
+    private getPositiveIntegerParameter(input: string | null): number | undefined {
+        if (!input) {
+            return undefined;
+        }
+
+        const value = parseInt(input);
+
+        return value > 0 ? value : undefined;
+    }
+
+    private getStringParameter(input: string | null): string | undefined {
+        if (!input || !input.trim()) {
+            return undefined;
+        }
+
+        return input.trim();
+    }
+
+    // #endregion QueryString
+}
+
+export const searchService = new SearchService();