AlfSearchList.js

/**
 * Copyright (C) 2005-2016 Alfresco Software Limited.
 *
 * This file is part of Alfresco
 *
 * Alfresco is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Alfresco is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with Alfresco. If not, see <http://www.gnu.org/licenses/>.
 */

/**
 * Extends the [sortable paginated list]{@link module:alfresco/lists/AlfSortablePaginatedList} to
 * handle search specific data.
 *
 * @module alfresco/search/AlfSearchList
 * @extends alfresco/lists/AlfSortablePaginatedList
 * @author Dave Draper
 */
define(["dojo/_base/declare",
        "alfresco/lists/AlfSortablePaginatedList",
        "alfresco/core/topics",
        "dojo/_base/array",
        "dojo/_base/lang",
        "dojo/dom-class",
        "alfresco/util/hashUtils",
        "dojo/io-query",
        "alfresco/core/ArrayUtils",
        "alfresco/core/ObjectTypeUtils",
        "alfresco/search/AlfSearchListView"],
        function(declare, AlfSortablePaginatedList, topics, array, lang, domClass, hashUtils, ioQuery, arrayUtils, ObjectTypeUtils) {

   return declare([AlfSortablePaginatedList], {

      /**
       * An array of the i18n files to use with this widget.
       *
       * @instance
       * @type {object[]}
       * @default [{i18nFile: "./i18n/AlfSearchList.properties"}]
       */
      i18nRequirements: [{i18nFile: "./i18n/AlfSearchList.properties"}],

      /**
       * An array of the CSS files to use with this widget.
       *
       * @instance
       * @type {object[]}
       * @default [{cssFile:"./css/AlfSearchList.css"}]
       */
      cssRequirements: [{cssFile:"./css/AlfSearchList.css"}],

      /**
       * An optional map of additional key/value pairs of query parameters to apply to all
       * searches.
       *
       * @instance
       * @type {object}
       * @default
       * @since 1.0.96
       */
      additionalQueryParameters: null,

      /**
       * The facet fields to include in searches. This is updated by the onIncludeFacetRequest function.
       *
       * @instance
       * @type {string}
       * @default
       */
      facetFields: "",

      /**
       * The filters of facets that should be applied to search queries. This can either be configured
       * when the widget is created or can be set via the browser hash fragment.
       *
       * @instance
       * @type {object}
       * @default
       */
      facetFilters: null,

      /**
       * This indicates whether or not to hide or display the included facets details when
       * results are loaded. This is initialised to true, but will be changed to false if
       * any facets are requested to be included in the page.
       *
       * @instance
       * @type {boolean}
       * @default
       */
      hideFacets: true,

      /**
       * Overrides the [mixed in default]{@link module:alfresco/lists/SelectedItemStateMixin#itemKeyProperty}
       * to set a property more applicable to search APIs.
       *
       * @instance
       * @type {string}
       * @default
       * @since 1.0.41
       */
      itemKeyProperty: "nodeRef",

      /**
       * The message key to use when displaying the number of results found.
       * 
       * @instance
       * @type {string}
       * @default
       * @since 1.0.70
       */
      resultsCountMessage: "faceted-search.results-menu.results-found-patch",

      /**
       * The current term to search on
       *
       * @instance
       * @type {string}
       * @default
       */
      searchTerm: "",

      /**
       * The initially selected scope. This should either be "repo", "all_sites" or the shortname of a
       * specific site.
       *
       * @instance
       * @type {string}
       * @default
       */
      selectedScope: "repo",

      /**
       * Include spell checking in search requests.
       *
       * @instance
       * @type {boolean}
       * @default
       */
      spellcheck: true,

      /**
       * Overrides the [default value]{@link module:alfresco/lists/AlfList#totalResultsProperty} to use
       * the property expected when using the search API.
       *
       * @instance
       * @type {string}
       * @default
       * @since 1.0.32
       */
      totalResultsProperty: "numberFound",

      /**
       * Overrides the [inherited default]{@link module:alfresco/lists/AlfHashList#updateInstanceValues}
       * to ensure that instance values should be updated from the hash. This only appliees when
       * [useHash]{@link module:alfresco/lists/AlfHashList#useHash} is configured to be true.
       *
       * @instance
       * @type {boolean}
       * @default
       */
      updateInstanceValues: true,

      /**
       * The vars and terms showing on the url hash that should be reset for a new search.
       *
       * @instance
       * @type {string[]}
       * @default ["facetFilters", "query"]
       */
      _resetVars: ["facetFilters", "query"],

      /**
       * Extends the [inherited function]{@link module:alfresco/lists/AlfSortablePaginatedList#postMixInProperties}
       * 
       * @instance
       */
      postMixInProperties: function alfresco_search_AlfSearchList__postMixInProperties() {
         this.inherited(arguments);
         this._suspendSpellCheck = false;
         this._cleanResettableVars();

         if (this.useHash === true)
         {
            // Push the core hash update variables into the array configured by the extended AlfSortablePaginatedList
            this._coreHashVars.push("searchTerm","scope","facetFilters");
         }

         // NOTE: This is required to ensure that no search is performed when no search hash variables are
         //       initially provided. Added for backwards compatibility.
         this.currentFilter = {};
      },

      /**
       * Reloads the data by making a search using the currently set search attributes. Typically
       * called following actions
       *
       * @instance
       * @param {object} payload The payload of the publication requesting the reload
       */
      onReloadData: function alfresco_search_AlfSearchList__onReloadData() {
         this.resetResultsList();
         this.loadData();
      },

      /**
       * Extends the [inherited function]{@link module:alfresco/lists/AlfSortablePaginatedList#setupSubscriptions}
       * to subscribe to search specific topics.
       *
       * @instance
       */
      setupSubscriptions: function alfresco_search_AlfSearchList__setupSubscriptions() {
         this.inherited(arguments);
         this.alfSubscribe("ALF_SET_SEARCH_TERM", lang.hitch(this, this.onSearchTermRequest));
         this.alfSubscribe("ALF_INCLUDE_FACET", lang.hitch(this, this.onIncludeFacetRequest));
         this.alfSubscribe("ALF_APPLY_FACET_FILTER", lang.hitch(this, this.onApplyFacetFilter));
         this.alfSubscribe("ALF_REMOVE_FACET_FILTER", lang.hitch(this, this.onRemoveFacetFilter));
         this.alfSubscribe("ALF_SEARCHLIST_SCOPE_SELECTION", lang.hitch(this, this.onScopeSelection));
         this.alfSubscribe("ALF_ADVANCED_SEARCH", lang.hitch(this, this.onAdvancedSearch));
      },

      /**
       * Overrides the [inherited function]{@link module:alfresco/lists/AlfList#setDisplayMessages}
       * to set search specific messages.
       *
       * @instance
       */
      setDisplayMessages: function alfresco_search_AlfSearchList__setDisplayMessages() {
         this.noDataMessage = this.message("searchlist.no.data.message");
         this.fetchingDataMessage = this.message("searchlist.loading.data.message");
         this.renderingViewMessage = this.message("searchlist.rendering.data.message");
         this.fetchingMoreDataMessage = this.message("searchlist.loading.data.message");
         this.dataFailureMessage = this.message("searchlist.data.failure.message");
      },

      /**
       * Updates the current search term. Note that this is not currently sufficient for setting complete
       * search data (such as facets, filters, sort order, etc) so this will need to be iterated on as
       * needed.
       *
       * @instance
       * @param {object} payload The details of the search term to set
       */
      onSearchTermRequest: function alfresco_search_AlfSearchList__onSearchTermRequest(payload) {
         this.alfLog("log", "Setting search term", payload, this);

         var currHash;
         var searchTerm = lang.getObject("searchTerm", false, payload);
         if (searchTerm === null || searchTerm === undefined)
         {
            this.alfLog("warn", "No searchTerm provided on request", payload, this);
         }
         else if (searchTerm === this.searchTerm)
         {
            // The requested search term is the same as the previous one...
            // We want to allow duplicate searches to be made (to address eventual consistency issues)
            // but we want to prevent concurrent requests using the same data...
            if (this.requestInProgress === true)
            {
               // If a request is currently in progress, then we can just ignore this request.
            }
            else
            {
               if (payload.spellcheck === false)
               {
                  this._suspendSpellCheck = true;
               }

               if (this.useHash === true)
               {
                  // If a request is NOT in progress then we need to manually request a new search, because re-setting
                  // the hash will not trigger the changeFilter function....
                  // If the current hash includes a term from the resetHashTerms array, we need to clear those terms before
                  // setting a search term (even if it is the same), in this case updating the hash will trigger the search...
                  currHash = hashUtils.getHash();
                  if (this._cleanResettableHashTerms(currHash))
                  {
                     currHash.searchTerm = this.searchTerm;
                     this.alfPublish("ALF_NAVIGATE_TO_PAGE", {
                        url: ioQuery.objectToQuery(currHash),
                        type: "HASH"
                     }, true);
                  }
                  else
                  {
                     // The current hash has no resettable terms so we need to trigger a manual search...
                     this.resetResultsList();
                     this.loadData();
                  }
               }
               else
               {
                  // When not using URL hashes, just apply the new search...
                  this.resetResultsList();
                  this.loadData();
               }
            }
         }
         else
         {
            // The requested search term is new, so updating the hash will result in a new search...
            this.searchTerm = searchTerm;
            if (this.useHash === true)
            {
               currHash = hashUtils.getHash();
               this._cleanResettableHashTerms(currHash);
               currHash.searchTerm = this.searchTerm;
               this.alfPublish("ALF_NAVIGATE_TO_PAGE", {
                  url: ioQuery.objectToQuery(currHash),
                  type: "HASH"
               }, true);
            }
            else
            {
               this.resetResultsList();
               this.loadData();
            }
         }
      },

      /**
       * Handle advanced search requests.
       *
       * @instance
       * @param {object} payload The details of what to search for.
       */
      onAdvancedSearch: function alfresco_search_AlfSearchList__onAdvancedSearch(payload) {
         this.resetResultsList();
         this.alfCleanFrameworkAttributes(payload, true);
         this.searchTerm = payload.searchTerm;
         delete payload.searchTerm;
         this.query = payload;
         this.loadData();
      },

      /**
       *
       *
       * @instance
       * @param {object} payload The details of the scope selected.
       */
      onScopeSelection: function alfresco_search_AlfSearchList__onScopeSelection(payload) {
         this.alfLog("log", "Scope selection received", payload, this);
         var scope = lang.getObject("value", false, payload);
         if (scope === null || scope === undefined)
         {
            this.alfLog("warn", "No 'value' attribute provided in scope selection payload", payload, this);
         }
         else if (scope === this.selectedScope)
         {
            this.alfLog("log", "Scope requested is currently set", scope, this);
         }
         else
         {
            this.selectedScope = scope;
            if (scope === "repo" || scope === "all_sites")
            {
               this.siteId = "";
            }
            else
            {
               this.siteId = scope;
            }

            if (this.useHash === true)
            {
               var currHash = hashUtils.getHash();
               currHash.scope = scope;
            
               // Update the hash to trigger a search...
               this.alfPublish("ALF_NAVIGATE_TO_PAGE", {
                  url: ioQuery.objectToQuery(currHash),
                  type: "HASH"
               }, true);
            }
            else
            {
               this.resetResultsList();
               this.loadData();
            }
         }
      },

      /**
       *
       * @instance
       * @param {object} payload The details of the facet to include
       */
      onIncludeFacetRequest: function alfresco_search_AlfSearchList__onIncludeFacetRequest(payload) {
         this.alfLog("log", "Adding facet filter", payload, this);
         var qname = lang.getObject("qname", false, payload);
         var blockIncludeFacetRequest = lang.getObject("blockIncludeFacetRequest", false, payload);
         if (qname === null || qname === undefined)
         {
            this.alfLog("warn", "No qname provided when adding facet field", payload, this);
         }
         else if (blockIncludeFacetRequest !== null && blockIncludeFacetRequest === true)
         {
            // Don't include the facet in the facet fields, however indicate that facet
            this.hideFacets = false;
         }
         else
         {
            // Make sure each facet is only included once (the search API is not tolerant of duplicates)...
            // Even if multiple widgets want to include the same facet, they will all receive the same
            // publication on search results...
            this.hideFacets = false;
            var f = this.facetFields.split(",");
            var alreadyAdded = array.some(f, function(currQName) {
               return currQName === qname;
            });
            if (alreadyAdded)
            {
               // No action required - the request QName has already been included
            }
            else
            {
               this.facetFields = (this.facetFields !== "") ? this.facetFields + "," + qname : qname;
            }
         }
      },

      /**
       * This function is called as a result of publishing on the "ALF_APPLY_FACET_FILTER" topic. It will
       * update the current [filters]{@link module:alfresco/search/AlfSearchList#facetFilters}
       * object with a new entry for the request filter.
       *
       * @instance
       * @param {object} payload The details of the facet filter to apply
       */
      onApplyFacetFilter: function alfresco_search_AlfSearchList__onApplyFacetFilter(payload) {
         this.alfLog("log", "Filtering on facet", payload, this);
         var filter = lang.getObject("filter", false, payload);
         if (filter === null || filter === undefined)
         {
            this.alfLog("warn", "No filter provided when filtering by facet", payload, this);
         }
         else
         {
            this.facetFilters[filter] = true;
            if (this.useHash === true)
            {
               this.updateFilterHash(filter, "add");
            }
            else
            {
               this.resetResultsList();
               this.loadData();
            }
         }
      },

      /**
       * This function is called as a result of publishing on the "ALF_REMOVE_FACET_FILTER" topic. It will
       * update the current [filters]{@link module:alfresco/search/AlfSearchList#facetFilters}
       * object to delete the supplied filter
       *
       * @instance
       * @param {object} payload The details of the facet filter to apply
       */
      onRemoveFacetFilter: function alfresco_search_AlfSearchList__onRemoveFacetFilter(payload) {
         this.alfLog("log", "Removing facet filter", payload, this);
         delete this.facetFilters[payload.filter];
         if (this.useHash === true)
         {
            this.updateFilterHash(payload.filter, "remove");
         }
         else
         {
            this.resetResultsList();
            this.loadData();
         }
      },

      /**
       * Performs updates to the url hash as facets are selected and de-selected
       *
       * @instance
       *
       * @fires ALF_NAVIGATE_TO_PAGE
       */
      updateFilterHash: function alfresco_search_AlfSearchList__updateFilterHash(fullFilter, mode) {
         // Get the existing hash and extract the individual facetFilters into an array
         var aHash = hashUtils.getHash(),
             facetFilters = aHash.facetFilters ? aHash.facetFilters : "",
             facetFiltersArr = facetFilters === "" ? [] : facetFilters.split(",");

         // Add or remove the filter from the hash object
         if(mode === "add" && !arrayUtils.arrayContains(facetFiltersArr, fullFilter))
         {
            facetFiltersArr.push(fullFilter);
         }
         else if (mode === "remove" && arrayUtils.arrayContains(facetFiltersArr, fullFilter))
         {
            facetFiltersArr.splice(facetFiltersArr.indexOf(fullFilter), 1);
         }

         // Put the manipulated filters back into the hash object or remove the property if empty
         if(facetFiltersArr.length < 1)
         {
            delete aHash.facetFilters;
         }
         else
         {
            aHash.facetFilters = facetFiltersArr.join();
         }

         // Send the hash value back to navigation
         this.alfPublish("ALF_NAVIGATE_TO_PAGE", {
            url: ioQuery.objectToQuery(aHash),
            type: "HASH"
         }, true);
      },

      /**
       * If [useHash]{@link module:alfresco/lists/AlfHashList#useHash} has been set to true
       * then this function will be called whenever the browser hash fragment is modified. It will update
       * the attributes of this instance with the values provided in the fragment.
       *
       * @instance
       * @param {object} payload
       */
      onHashChanged: function alfresco_search_AlfSearchList__onHashChanged(payload) {
         this.alfLog("log", "Hash change detected", payload, this);

         // Only update if the payload contains one of the variables we care about
         if(this.doHashVarUpdate(payload, this.updateInstanceValues))
         {
            // If the search term has changed then we want to delete the facet filters as
            // they might not be applicable to the new search results...
            var newSearchTerm = lang.getObject("searchTerm", false, payload);
            if (newSearchTerm !== this.searchTerm)
            {
               this._cleanResettableVars();
            }

            var pageOrSizeHasChanged = !this.useInfiniteScroll && (this.currentPage !== payload.currentPage || this.currentPageSize !== payload.currentPageSize);

            // The facet filters need to be handled directly because they are NOT just passed as
            // a simple string. Create a new object for the filters and then break up the filters
            // based on comma delimition and assign each element as a new key in the filters object
            var filters = lang.getObject("facetFilters", false, payload);
            if (filters !== null && filters !== undefined)
            {
               var ff = payload.facetFilters = {};
               var fArr = filters.split(",");
               array.forEach(fArr, function(filter) {
                  ff[filter] = true;
               }, this);
            }
            else
            {
               this._cleanResettableVars();
            }

            lang.mixin(this, payload);
            this.resetResultsList(pageOrSizeHasChanged);
            this.loadData();
         }
      },

      /**
       * Processes all the current search arguments into a payload that is published to the [Search Service]{@link module:alfresco/services/SearchService}
       * to perform the actual search request
       *
       * @instance
       */
      loadData: function alfresco_search_AlfSearchList__loadData() {
         // jshint maxcomplexity:false,maxstatements:false
         
         // Ensure any no data node is hidden...
         domClass.add(this.noDataNode, "share-hidden");

         var key;
         if (this.requestInProgress)
         {
            // TODO: Inform user that request is in progress?
            this.alfLog("log", "Search request ignored because progress is already in progress");
            this._searchPending = true;
            if (this.currentRequestId)
            {
                this.alfPublish("ALF_STOP_SEARCH_REQUEST", {
                   requestId: this.currentRequestId
                }, true);
            }
         }
         else
         {
            // InfiniteScroll uses pagination under the covers.
            var startIndex = (this.currentPage - 1) * this.currentPageSize;
            if (!this.useInfiniteScroll ||
                !this.currentData ||
                this.currentData.numberFound === -1 || // Indicate no results found on previous search
                this.currentData.numberFound >= startIndex)
            {
               this.alfPublish(this.requestInProgressTopic, {});
               this.showLoadingMessage();

               // When loading a page containing filters to apply as a URL hash parameter, the facetFilters attribute
               // will be a string, but when applied after the page is loaded it will be an object. We need to treat
               // each case differently...
               var filters = "";
               if (ObjectTypeUtils.isString(this.facetFilters))
               {
                  // When facetFilters is a string it will be delimited by commas, the string can be split to get an array
                  // of each filter to apply...
                  var filtersArray = this.facetFilters.split(",");
                  array.forEach(filtersArray, function(filter) {
                     filters = filters + filter.replace(/\.__.u/g, "").replace(/\.__/g, "") + ",";
                  });
               }
               else
               {
                  // When facetFilters is an object, each key will be a filter to be applied...
                  for (key in this.facetFilters)
                  {
                     if (this.facetFilters.hasOwnProperty(key))
                     {
                        filters = filters + key.replace(/\.__.u/g, "").replace(/\.__/g, "") + ",";
                     }
                  }
               }
               // Trim any trailing comma...
               filters = filters.substring(0, filters.length - 1);

               // Make sure the repo param is set appropriately...
               // The repo instance variable trumps everything else...
               var siteId = this.siteId;
               var scope = this.selectedScope;
               if (this.useHash === true)
               {
                  // Unfortunately we made the error of using "scope" on the URL hash and
                  // "selectedScope" as the widget attribute. This means that we have to special
                  // case useHash being set to true to use the appropriate value for the mode being used...
                  siteId = (this.scope === "repo" || this.scope === "all_sites") ? "" : scope;
                  scope = this.scope || scope.toLowerCase();
               }
               
               this.currentRequestId = this.generateUuid();
               var searchPayload = {
                  term: this.searchTerm,
                  facetFields: this.facetFields,
                  filters: filters,
                  sortAscending: this.sortAscending,
                  sortField: this.sortField,
                  site: siteId,
                  rootNode: this.rootNode,
                  repo: scope === "repo",
                  requestId: this.currentRequestId,
                  pageSize: this.currentPageSize,
                  maxResults: 0,
                  startIndex: startIndex,
                  spellcheck: this.spellcheck && !this._suspendSpellCheck
               };

               if (this.query)
               {
                  this.alfCleanFrameworkAttributes(this.query, true);

                  if(typeof this.query === "string")
                  {
                     this.query = JSON.parse(this.query);
                  }

                  for (key in this.query)
                  {
                     if (this.query.hasOwnProperty(key))
                     {
                        searchPayload[key] = this.query[key];
                     }
                  }
               }

               // Add in any additional query parameters...
               if (this.additionalQueryParameters)
               {
                  for (key in this.additionalQueryParameters)
                  {
                     if (this.additionalQueryParameters.hasOwnProperty(key))
                     {
                        searchPayload[key] = this.additionalQueryParameters[key];
                     }
                  }
               }

               // Set a response topic that is scoped to this widget...
               searchPayload.alfResponseTopic = this.pubSubScope + "ALF_RETRIEVE_DOCUMENTS_REQUEST";
               this.alfPublish(topics.SEARCH_REQUEST, searchPayload, true);
            }
            else
            {
               this.alfLog("log", "No more data to to retrieve, cancelling search request", this);
            }
         }
      },

      /**
       * Handles successful calls to get data from the repository.
       *
       * @instance
       * @param {object} response The response object
       * @param {object} originalRequestConfig The configuration that was passed to the [serviceXhr]{@link module:alfresco/core/CoreXhr#serviceXhr} function
       */
      onDataLoadSuccess: function alfresco_search_AlfSearchList__onDataLoadSuccess(payload) {
         /* jshint maxcomplexity:false */
         this.alfLog("log", "Search Results Loaded", payload, this);

         var newData = payload.response;
         this.currentData = newData; // Some code below expects this even if the view is null.

         // Reset suspending the spell check...
         this._suspendSpellCheck = false;

         // Re-render the current view with the new data...
         var view = this.viewMap[this._currentlySelectedView];
         if (view !== null)
         {
            this.showRenderingMessage();
            this.processLoadedData(payload.response || this.currentData);
            if (this.useInfiniteScroll)
            {
               view.augmentData(newData);
               this.currentData = view.getData();
            }
            else
            {
               view.setData(newData);
            }

            view.renderView(this.useInfiniteScroll);
            this.showView(view);
         }

         // TODO: This should probably be in the SearchService... but will leave here for now...
         var facets = lang.getObject("response.facets", false, payload);
         var filters = lang.getObject("requestConfig.query.encodedFilters", false, payload);
         if (facets !== null && facets !== undefined)
         {
            for (var key in facets)
            {
               if (facets.hasOwnProperty(key))
               {
                  var facet = key;
                  if (key[0] === "@")
                  {
                     facet = key.substring(1);
                  }
                  this.alfPublish("ALF_FACET_RESULTS_" + facet, {
                     facetResults: facets[key],
                     activeFilters: filters
                  });
               }
            }
         }

         // Handle any spell checking data included in the results...
         this.handleSpellCheck(payload);

         var resultsCount = this.currentData.numberFound !== -1 ? this.currentData.numberFound : 0;
         if (resultsCount !== null)
         {
            // Publish the number of search results found...
            this.alfPublish("ALF_SEARCH_RESULTS_COUNT", {
               count: resultsCount,
               label: this.message(this.resultsCountMessage, {
                  0: resultsCount
               })
            });
         }

         this.alfPublish("ALF_HIDE_FACETS", {
            hide: this.hideFacets === true || resultsCount === 0
         });

         // This request has finished, allow another one to be triggered.
         this.alfPublish(this.requestFinishedTopic, {});

         // Force a resize of the sidebar container to take the new height of the view into account...
         this.alfPublish("ALF_RESIZE_SIDEBAR", {});
      },

      /**
       * This function can be called to handle spell check results. If a search term did not match to any
       * results or similar search terms yield better results then the search API may either have carried out
       * the alternative search or has provided some alternative suggestions to search for. This function
       * checks the search result payload and publishes on the "ALF_SPELL_CHECK_SEARCH_TERM" and
       * "ALF_SPELL_CHECK_SEARCH_SUGGESTIONS" topics respectively with that data.
       *
       * @instance
       * @param {object} payload The payload containing the search result data
       */
      handleSpellCheck: function alfresco_search_AlfSearchList__handleSpellCheck(payload) {
         // Check to see whether or not spell checking was applied...
         var spellcheck = lang.getObject("response.spellcheck", false, payload);
         if (spellcheck !== null && spellcheck !== undefined)
         {
            if (spellcheck.searchedFor !== null && spellcheck.searchedFor !== undefined)
            {
               // Update the local state to reflect what was actually searched for...
               // this.searchTerm = spellcheck.searchedFor;

               // This means that an alternative search term was used...
               this.alfPublish("ALF_SPELL_CHECK_SEARCH_TERM", {
                  searchRequest: spellcheck.searchRequest,
                  searchedFor: spellcheck.searchedFor
               });
            }
            else if (spellcheck.searchSuggestions !== null && spellcheck.searchSuggestions !== undefined)
            {
               // This means that an alternative search was not performed, but suggested searches
               // are available...
               var suggestions = [];
               array.forEach(spellcheck.searchSuggestions, function(suggestion) {
                  suggestions.push({
                     term: suggestion
                  });
               });
               this.alfPublish("ALF_SPELL_CHECK_SEARCH_SUGGESTIONS", {
                  searchRequest: spellcheck.searchRequest,
                  searchSuggestions: suggestions
               });
            }
            else
            {
               // This means that the requested search term was used. No action required.
            }
         }
      },

      /**
       * Clear Old results from list & reset counts.
       *
       * @instance
       */
      resetResultsList: function alfresco_search_AlfSearchList__resetResultsList(doNotChangePages) {
         if(!doNotChangePages) {
            this.startIndex = 0;
            this.currentPage = 1;
         }
         this.hideChildren(this.domNode);
         this.clearViews();
      },

      /**
       * Clean resettable variables based on resetVars array.
       *
       * @instance
       */
      _cleanResettableVars: function alfresco_search_AlfSearchList___cleanResettableVars() {
         for (var i = 0; i < this._resetVars.length; i++) {
            this[this._resetVars[i]] = {};
         }
      },

      /**
       * Clean resettable hash terms based on resetVars array.
       *
       * @instance
       * @param {object} currHash An object containing current hash values
       * @return boolean
       */
      _cleanResettableHashTerms: function alfresco_search_AlfSearchList___cleanResettableHashTerms(currHash) {
         var hasTerm = false;
         for (var term in currHash) {
            if(this._resetVars.indexOf(term) !== -1 && currHash[term] !== null && currHash[term] !== "")
            {
               hasTerm = true;
               delete currHash[term];
            }
         }
         return hasTerm;
      },

      /**
       * Extends the [inherited function]{@link module:alfresco/lists/AlfList#onRequestFinished} to reissue
       * a search request if additional search data was provided whilst a request was in-progress.
       *
       * @instance
       */
      onRequestFinished: function alfresco_search_AlfSearchList___onRequestFinished() {
         this.inherited(arguments);
         if (this._searchPending ===true)
         {
            this._searchPending = false;
            this.loadData();
         }
      }
   });
});