With FS4SP,  these query suggestions are automatically created over a period of time based on how often the users search for a specific query within a certain timeframe. Sometimes, it can however make sense to modify the query suggestions manually – and to help us do that, we can always lean on PowerShell.

The script I have implemented, has the following parameters:

.\QuerySuggestions.ps1 -file [fileName] -action [add|delete] -queryssa [querySSAName]

where file is the file with the query suggestion phrases (one per line), action decides if the query suggestions should be added or deleted, queryssa is the name of the Query SSA. And now for the actual code.

#Get input
param
(
    [string]$file,
    [string]$action,
    [string]$queryssa
)

function LoadQueryCompletion()
{
    # Read input file with stuff that you should add to the Query suggestion list
    if (test-path $file)
    {
        log VERBOSE "Reading file: $file"
	$input = Get-Content $file
    }
    else
    {
        log ERROR "File noe found. Exiting script."
        exit 1
    }
    # Get SSA search application
    $searchapp = Get-SPEnterpriseSearchServiceApplication -Identity $queryssa

    # Populating a dictionary with the query suggestions that have already been added before
    $query_suggestions = Get-SPEnterpriseSearchLanguageResourcePhrase -SearchApplication $searchapp -Language En-Us -Type QuerySuggestionAlwaysSuggest
    $already_dict = @{}
    foreach ($term in $query_suggestions)
    {
        if (!$term){ continue }
        $already_dict.Add($term.Phrase,$term.Phrase)
    }

    if ($action -eq "add")
	{
	    foreach ($entry in $input) {
	        if ($already_dict.ContainsKey($entry))
	        {
	            log WARNING "Key already added: $entry"
	        }
	        else
	        {

			try {
				log VERBOSE "Adding entry ($entry) with language En-US"
			    	$nooutput = new-spenterprisesearchlanguageresourcephrase -SearchApplication $searchapp -Language En-Us -Type QuerySuggestionAlwaysSuggest -Name $entry
				$already_dict.Add($entry,$entry)
			}catch {
				log ERROR "Could not add entry ($entry). Exiting script."
				exit 1
			}
	        }
	    }
	}
	elseif ($action -eq "delete")
	{
		foreach ($entry in $input) {
			try {
				if ($already_dict.ContainsKey($entry)) {
					log VERBOSE "Removing entry ($entry) with language En-US"
			    	        $nooutput = remove-spenterprisesearchlanguageresourcephrase -SearchApplication $searchapp -Language En-Us -Type QuerySuggestionAlwaysSuggest -Identity $entry -Confirm:$false
					$already_dict.Remove($entry)
				}else{
					log WARNING "Entry ($entry) has not been added as a query suggestion"
				}
			}catch {
				log ERROR "Could not remove entry ($entry)."
			}
	    }
	}
	else
	{
		log ERROR "-action parameter contains an invalid value. Exiting script."
	}

    #Run timerjob manually to upload entries from DB
    Start-SPTimerJob -Identity "prepare query suggestions"

    log VERBOSE "Finished loading query completion phrases."
}

#Main
$spInstalled = Get-PSSnapin | Select-String Sharepoint
if (!$spInstalled)
{
    Add-PSSnapin Microsoft.Sharepoint.PowerShell
}
LoadQueryCompletion

If you want to include the logging output , add this to the top of the PowerShell script.

# Log level to color mapping
$lc = @{
	VERBOSE="green";
	WARNING="yellow";
	ERROR="red";
	MESSAGE="blue";
}
function log([string] $level, [string] $message) {
	$date = get-date -uformat "%G-%m-%d %T"
	write-host "[$date] " -nonewline
	write-host -foregroundcolor $lc[$level] $level.padright(7) -nonewline
	write-host " $message"
}

If you’re really picky (like me), you should also consider having some kind of validation on the input parameters. For instance verifying that the file exists, that the action parameter contains a valid value, and that the Query SSA exists. You can check the last-mentioned by adding the following lines of code to the script.

$ssaExists = Get-SPEnterpriseSearchServiceApplication | Select-String $queryssa
if ($ssaExists -eq $null)
{
	log ERROR "-queryssa is invalid. Search Service Application does not exist. Exiting script."
	$queryssas = Get-SPEnterpriseSearchServiceApplication | Where-Object {$_.DefaultSearchProvider -eq "FASTSearch"}
	foreach ($queryssa in $queryssas)
        {
		if ($queryssa)
    	    	{
    			$name = $queryssa.Name
    			log VERBOSE "Found the following Query SSA: $name"
    	    	}
        }
}

After doing that, you should be ready to run the script on the SharePoint Admin server.

Afterwards, go to your FAST Search Center, and start typing one of the terms you have added. The result can look something like in the screenshot below.

In this blog post I will show how this can be automated in any given FAST Search for SharePoint installation. But first, just a short introduction to the extractors that we have out of the box:

• Companies – extracts company names based on a generic dictionary.
• Locations – extracts names of geographical locations based on a generic dictionary.
• Person names – extracts names of persons based on a generic dictionary.

In most cases, you will have companies, locations and person names that are specific to your company or organization. However, you may want to modify the built-in property extractors by adding inclusion lists and exclusion lists to improve the quality of these extractors. Typically you can use customer lists from your CRM system, employee information from your ERP system, and product listings you might have.

In order to accomplish this in an easy manner, we need some PowerShell magic.

First, just a quick overview of the input paramenters to the script:

.\PropertyExtraction.ps1 -file [fileName] -type [companies|personnames|locations] -addto [include|exclude]

where the file parameter is the list of properties to extract, the type parameter specifies which property we’re dealing with and the addto parameter sets if the properties will be added to the include list or the exclude list.

Below is a snippet of where the fun takes place in code.

function ImportEntities()
{
    #Setting term entity dictionary to be "companies", "locations" or "personnames"
    $entityExtractorContext = New-Object -TypeName Microsoft.SharePoint.Search.Extended.Administration.EntityExtractorContext
    $entityExtractors = $entityExtractorContext.TermEntityExtractors
    foreach ($extractor in $entityExtractors)
    {
        if ($extractor.Name -eq $type)
        {
            $entityExtractor = $extractor
            log VERBOSE "Setting extractor to: $type"
        }
    }

	log VERBOSE "Reading file: $file"
	try{ $input = Get-Content $file }
	catch{ log ERROR "Failed to read file: $file"}

    #Iterating over properties dictionary and adding them if they haven't been added before
    $input = Get-Content $file
    foreach($entity in $input)
    {
        if ($addto -eq "include")
		{
			if ( $entityExtractor.Inclusions.Contains($entity) )
	        {
	            log WARNING "Entity already added ($type): $entity"
	            continue
	        }
	        else
	        {
	            try {
					$entityExtractor.Inclusions.Add($entity)
					log VERBOSE "Added entity ($type): $entity"
				} catch {
					log ERROR "Failed to add entity ($type): $entity"
				}
			}
		}
		elseif ($addto -eq "exclude")
		{
			if ( $entityExtractor.Exclusions.Contains($entity) )
	        {
	            log WARNING "Entity already excluded ($type): $entity"
	            continue
	        }
	        else
	        {
	            try {
					$entityExtractor.Exclusions.Add($entity)
					log VERBOSE "Excluded entity ($type): $entity"
				}catch {
					log ERROR "Failed to exclude entity ($type): $entity"
				}
	        }
		}
    }
    log VERBOSE "Finished loading $type properties."
}

An example company list file could look like:

Apple
Comperio
Microsoft

If you did a crawl before starting on your white and black lists, you can use any noise in your navigators as input to the black list, and also entities missing in the white lists. An easy way to get all navigator values is to search for “#”, which will do a blank search showing all data you have access to.

Now that you have added the new white and/or black lists, you should schedule a new crawl and the quality of the entity refiners should be improved. Voila!