For the most part, Microsoft has done a great job integrating FAST into the SharePoint world, but there are certainly some areas where you notice there are actually two paradigms behind the scene: how things work in SharePoint, and how things (used to) work in FAST.

The primary key of the FS4SP index is one of those areas. In this post, I’ll try to make this a little more understandable.

First of all, the place where most people will notice that a primary key actually exists is in the crawl log on the FAST Content SSA.

Each indexed item is assigned an auto-incremented integer referred to as Item ID. All right, so let’s dig a little deeper.

If you’ve been reading up on FS4SP, you probably already know that there is an internal FAST-process called “qrserver”. It is responsible for receiving queries from the FAST Query SSA and internally forwarding the query to the actual index. You might also know that this process exposes a small web interface. For security reasons, it’s only available from within the server it runs on. More specifically: http://localhost:13280.

Searching for something here will return results in an internal XML format. The actual result items are listed under the <RESULTSET> tag a bit down in the XML. There are lots of things to talk about here, e.g. that the naming convention used internally in FAST is quite different to what is used when the results come back through the FAST Query SSA. A managed property for example, is referred to as a “field” internally. But let’s not fret over that now. Instead, let’s look at the first few properties of the first result:

After a few quick comparisons of the crawl log on the FAST Content SSA and the search results from the qrserver, it’s clear that the Item ID is stored in FS4SP’s index inside the property contentid. When comparing with the Item IDs listed on the FAST Content SSA, we also notice that SharePoint is prefixing the Item ID with “ssic://” when it’s stored in the index. In other words, the true primary key as used internally, is based on the pattern “ssic://[auto-incremented integer]”.

But as anyone who’s been using FAST pre-Microsoft can tell you, the contentid is actually not the primary key of the index. The real primary key is what’s stored inside the property internalid. The value of this property is the MD5 digest of the contentid, concatenated with the name of the content collection it is stored in. Let’s double-check, using our example. We had these two:

<FIELD NAME="internalid">8a832873c701c00135ce827d6c64c09c_sp</FIELD>
<FIELD NAME="contentid">ssic://33</FIELD>

Calculating the MD5 digest of the contentid correctly yields the internalid (sans the collection suffix):

md5(“ssic://33”) == “8a832873c701c00135ce827d6c64c09c”

Since the internalid is suffixed with the name of the collection, we can actually put several items with the same contentid into the index. The requirement being that they’re stored in separate collections, so that the concatenated internalid value becomes unique. In FS4SP however, we often use only the default “sp” collection. Luckily, SharePoint makes sure to assign the Item IDs so that they’re unique across all collections, hence creating unique internalid:s even though the items are in the same collection.

However, there are ways in FS4SP to index data without going through the FAST Content SSA, i.e. you can index data without letting SharePoint know about it. This happens when you’re using any of the FAST Search specific connectors or the command-line tool docpush. These tools talk directly with the index, bypassing SharePoint completely. Thus, the content id item won’t be assigned an Item ID using the “ssic://” pattern.

So, what happens instead? Let’s try it out. Using the docpush tool, we can send an arbitrary web page into the index:

Using the qrserver web interface, we inspect what was indexed:

In this case, the contentid property is the URL of the web page we specified. This makes sense as the URL is unique for the whole web, and as such it is also a good candidate for being a primary key in the index. A URL is just a special case of a URI, which is what many of the FS4SP command-line tools use when referring to the primary key of the index. Examples being the docpush tool (when deleting a item from the index with the –d switch) and the waadmin tool (used for retrieving link cardinality data for an indexed item).

To sum up with some key points:

• The primary key of the index is stored in a property called contentid, though in the SharePoint GUIs it is referred to as an Item ID and look slightly different. They relate to one another as: [contentid] = ssic://[item id]
• Items that are indexed using the connectors of the FAST Content SSA are assigned a contentid on the form “ssic://”…
• Items that are indexed with the FAST Search specific connectors or the docpush tool do not follow the same pattern, but are typically a proper URL or a value from a database.
• If a command-line tool calls for a “URI” to an indexed item, use whatever is stored in the item’s contentid property.

To accomplish this I use the Microsoft.Office.Server.Search.Administration.SearchServiceApplication class, and more specifically the AddNewLocationConfiguration and DeleteLocationConfiguration methods. I tried to use the same methods of the SearchServiceApplicationProxy first, but there seems to be an error using the AddNewLocationConfiguration method on proxy object.

AddNewLocationConfiguration takes a LocationConfiguration object as parameter, which can be created by loading in the xml from an OSDX file like this:

var searchLocation = new LocationConfiguration();
var stream = …stream to xml file…;
searchLocation.Import(stream);

As you see, adding is not too hard, but deleting is the problem. The DeleteLocationConfiguration method takes the id of a LocationConfiguration object as the parameter. But lo and behold, the Id property is defined as internal.

That means it’s not available for us to delete on. But we’re lucky to use .Net where reflection is possible. Buy using the helper class below we can get the value from the internal property. Note that the code could have used regular reflection, but emitting IL makes more optimized code, and I use this utility class a lot of other places where performance is an issue.

<span class="kwrd">public</span> <span class="kwrd">class</span> DynamicReflectionHelperforObject&lt;V&gt;{
    <span class="kwrd">public</span> <span class="kwrd">delegate</span> T GetPropertyFieldDelegate&lt;T&gt;(V obj);

    <span class="kwrd">public</span> <span class="kwrd">static</span> GetPropertyFieldDelegate&lt;C&gt; GetP&lt;C&gt;(<span class="kwrd">string</span> memberName)
    {
        Type v = <span class="kwrd">typeof</span>(V);
        PropertyInfo pi = v.GetProperty(memberName, BindingFlags.NonPublic | BindingFlags.Instance);
        <span class="kwrd">if</span> (pi == <span class="kwrd">null</span>)
            <span class="kwrd">throw</span> <span class="kwrd">new</span> NullReferenceException(<span class="str">"No Property or Field"</span>);

        DynamicMethod dm = <span class="kwrd">new</span> DynamicMethod(<span class="str">"GetPropertyorField_"</span> + memberName, <span class="kwrd">typeof</span>(C), <span class="kwrd">new</span> Type[] { v }, v.Module);        ILGenerator il = dm.GetILGenerator();
        il.Emit(OpCodes.Ldarg_0); <span class="rem">// loaded c, c is the return value
</span>        il.EmitCall(OpCodes.Call, pi.GetGetMethod(<span class="kwrd">true</span>), <span class="kwrd">null</span>);
        il.Emit(OpCodes.Ret);
        <span class="kwrd">return</span> (GetPropertyFieldDelegate&lt;C&gt;)dm.CreateDelegate(<span class="kwrd">typeof</span>(GetPropertyFieldDelegate&lt;C&gt;));
    }
}

<span class="kwrd">int</span> id = Helpers.DynamicReflectionHelperforObject&lt;LocationConfiguration&gt;
   .GetProperty&lt;<span class="kwrd">int</span>&gt;(<span class="str">"Id"</span>)
   .Invoke(frontLocation);
fastQuerySSA.DeleteLocationConfiguration(id);

Microsoft offers three different flavors of search for SharePoint 2010: Foundation, Standard and Enterprise. For each level upwards you get more feature and better search capabilities. One of the visual features included with FAST for SharePoint is Thumbnails and Previews for the search results, as listed on the comparison table below (Compare SharePoint Editions – Search).

Wouldn’t it be nice to have this feature on all versions of SharePoint? I will tell you how, as I demonstrated in a proof of concept talk at Arctic SharePoint Challenge 2011.

The Thumbnail and Preview feature is depending on Office Web Apps, which is an additional module you can install on all versions of SharePoint 2010 in order to get web based editing capabilities of Office documents (Word, Excel, PowerPoint and OneNote). Office Web Apps itself is free, but requires Volume Licensing for Microsoft Office 2010.

The API’s used for generating the thumbnails and the PowerPoint previews are the Office Mobile PowerPoint Web Handler Protocol and the Office Mobile Word Web Handler Protocol, both included with Office Web Apps. These API’s include functions to retrieve generated images of the documents as well as functions to retrieve the textual content within the documents. The API works for doc, docx, ppt and pptx files (Office 97-2010 formats).

The Word API is limited to generating a thumbnail for the first page in your document, while the PowerPoint API can generate an image of any slide as seen below.

If you have installed the Enterprise version of SharePoint you have the possibility to create a new Search Center based on the “FAST Search Center” template, even though FAST is not installed.

The FAST Search Center template features XSLT in the Core Results Web Part which renders javascript calls to functions in a file called search.js located in the _layouts folder. Search.js further implements the communication with the mobile API’s to generate the images.

There are quite a few lines of javascript to implement this feature, but if you are a bit experienced with javascript and ajax programming you would be able to program this feature yourself. This will allow you to get thumbnails and PowerPoint previews with any version of SharePoint, from the free Foundation version to the Enterprise version.

If you are less handy with javascript you can copy out the XSLT used in the Core Results WebPart in the FAST Search Center site template, modify it some, and use it with a search site based on the “Enterprise Search Center” template instead. This way you will get additional visual improvements to the standard search page without having to install FAST.

The quick way is to replace some of the xsl:params set by the web part with pre-set variables instead. If you have FAST installed, then the parameters will be set via the Core Results Webpart. As we are using the oob search we have to set these parameters as variables instead.

<xsl:variable name=“OpenPreviewLink“ select=“‘Preview’“ />

<xsl:variable name=“ClosePreviewLink“ select=“‘Close Preview’“ />

<xsl:variable name=“ThumbnailTooltipLoadingFailed“ select=“‘Loading failed!’“ />

<xsl:variable name=“ThumbnailTooltipLoading“ select=“‘Click to toggle preview’“ />

<xsl:variable name=“AAMZone“ select=“0“ />

<xsl:variable name=“PreviewWindowSize“ select=“160“ />

<xsl:variable name=“EnableDocumentPreviewPowerPoint“ select=“‘true’“ />

<xsl:variable name=“EnableDocumentPreviewWord“ select=“‘true’“ />

<xsl:variable name=“ConcurrentDocumentPreview“ select=“10“ />

<xsl:variable name=“TotalDocumentPreview“ select=“10“ />

I also had to modify the xslt two more places. Around line 665 and line 725 locate the FST_CheckForPreview call and change the function parameter

‘<xsl:value-of select=“sitename“/>’

with

‘http://rootsite’

where rootsite is the name of your SharePoint server url.

This was to ensure the calls to the Mobile API went to the top level site, as they failed when called on sub-site url’s.

That being said, there are several other good reasons for deploying FAST for SharePoint in your organization besides these visual enhancements. Capabilities to enrich and modify your content prior to indexing, thus tailoring search experience towards the real needs of your users, as well as the powerful query capabilities offered via FAST Query Language are just a couple of arguments for choosing FAST.

But then again, it never hurts to have moderate amounts of eye-candy on your search page, as it will increase the perceived quality of the results.

Instead of having a deployment script creating your properties, you could have an event receiver which creates your mappings once a site or list is provisioned. Or when some other action is going on.

So how do you go about doing this?

Well, first off Crawled and Managed Properties for FAST are a part of the index schema and is accessible via the following two namespaces:

Microsoft.SharePoint.Search.Extended.Administration Microsoft.SharePoint.Search.Extended.Administration.Schema

which are the namespaces used for working with the FAST components.

Below is a quick example showing how this can be done in code, with comments along the way to guide the process. It’s all pretty straight forward.

const string propertyName = “productname”;

// Get a reference to the Index Schema via the SchemaContext class

SchemaContext schemaContext = new SchemaContext();

Schema schema = schemaContext.Schema;

// Assign a guid to the custom Crawled Propery Category

Guid myGuid = new Guid(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1);

Category catGroup;

// Create if it does not exist

if (!schema.AllCategories.Contains(myGuid))

{

catGroup = schema.AllCategories.Create(“My Crawled Properties”, myGuid);

}

else

{

catGroup = schema.AllCategories[myGuid];

}

// Create a new crawled property if it doesn’t exist

CrawledProperty cp = catGroup.GetAllCrawledProperties().Where(

c => c.Name == propertyName && c.VariantType == 31 && c.Propset == myGuid).FirstOrDefault();

if (cp == null) cp = catGroup.CreateCrawledProperty(propertyName, myGuid, 31);

// Create a new managed property if it doesn’t exist

ManagedProperty mp;

if (!schema.AllManagedProperties.Contains(propertyName))

{

mp = schema.AllManagedProperties.Create(propertyName, “”, ManagedType.Text);

}

else

{

mp = schema.AllManagedProperties[propertyName];

}

// Create a new crawled to managed property mapping if it doesn’t exit

CrawledPropertyMapping mapping = mp.GetCrawledPropertyMappings();

if (!mapping.Contains(cp))

{

mapping.Add(cp);

mp.SetCrawledPropertyMappings(mapping);

}

// Get a reference to the default full text index (first one)

FullTextIndex fti = schema.AllFullTextIndecies.First();

// Get the full text index mapping from the Managed Property

FullTextIndexMappingCollection fullTextIndexMappingCollection = mp.GetFullTextIndexMappings();

FullTextIndexMapping indexMapping =

fullTextIndexMappingCollection.Where(ftpMap => ftpMap.FullTextIndex.Name == fti.Name).FirstOrDefault();

// Set a mapping to importance level 6, if it’s not already set to something else

if (indexMapping == null || !fullTextIndexMappingCollection.Contains(indexMapping))

{

fullTextIndexMappingCollection.Create(fti, 6);

}

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.

But what if you are located in a different part of the world, speaking some obscure language like Norwegian, which is my native tongue, and where names are sounding nothing like English ones? What then?Phonetics and nicknames are handled by the Microsoft Speech Platform. Default only en-us is installed, but you can download and install the runtime for your particular language. Your mileage seems to vary with how good the other language runtimes actually are, and my tests show that the English one usually gives the best results.

Still, you might have to add some nick names of your own. Here’s how:

SharePoint PowerShell has a command called New-SPEnterpriseSearchLanguageResourcePhrase. This command can take a Type parameter of Nickname (which for some reason is not listed on the TechNet page, but is documented on the Get version of the same command).

If I wanted to add the nickname slick for my own name, and vice versa I would execute the following PowerShell Commands:

$ssa = Get-SPEnterpriseSearchServiceApplication FASTQuery

New-SPEnterpriseSearchLanguageResourcePhrase –Name mikael -Language “en-US” –Type “Nickname” –Mapping slick -SearchApplication $ssa

New-SPEnterpriseSearchLanguageResourcePhrase –Name slick -Language “en-US” –Type “Nickname” –Mapping mikael -SearchApplication $ssa

FASTQuery is the name of my Query SSA. Also note the Language parameter. Your query language has to match this in order for the nicknames to be used, and my suggestion is to set this to for the language you choose to use for phonetics and nicknames.

Then in order to re-generate the language files run the command:

Start-SPTimerJob -Identity “Prepare query suggestions”

And your nicknames should be up and running from the search page.

To the rescue comes PowerShell. Since all FAST servers have PowerShell installed you can create a PowerShell script and use this. All you need is notepad :) This gives the flexibility of trying out stuff without recompiling. But the cost is speed of execution. So you might want to port the code over to e.g. C# when you are done testing your code.

See my post “How To: Debug and log FAST Search pipeline extensibility stages in Visual Studio” on how to do this in C#, and also how to create your own property set with PowerShell commands.

In order to register the script in pipelineextensibility.xml we prepend the ps1 file with the PowerShell runtime

<span style="color: #0000ff;">&lt;</span><span style="color: #800000;">Run</span> <span style="color: #ff0000;">command</span><span style="color: #0000ff;">="C:\Windows\System32\WindowsPowerShell\v1.0\PowerShell.exe C:\FASTSearch\pipelinemodules\concept.ps1 %(input)s %(output)s"</span><span style="color: #0000ff;">&gt;</span>   <span style="color: #0000ff;">&lt;</span><span style="color: #800000;">Input</span><span style="color: #0000ff;">&gt;</span>           <span style="color: #0000ff;">&lt;</span><span style="color: #800000;">CrawledProperty</span> <span style="color: #ff0000;">propertySet</span><span style="color: #0000ff;">="48385C54-CDFC-4E84-8117-C95B3CF8911C"</span> <span style="color: #ff0000;">varType</span><span style="color: #0000ff;">="31"</span> <span style="color: #ff0000;">propertyName</span><span style="color: #0000ff;">="docvector"</span><span style="color: #0000ff;">/&gt;</span>   <span style="color: #0000ff;">&lt;/</span><span style="color: #800000;">Input</span><span style="color: #0000ff;">&gt;</span>   <span style="color: #0000ff;">&lt;</span><span style="color: #800000;">Output</span><span style="color: #0000ff;">&gt;</span>     <span style="color: #0000ff;">&lt;</span><span style="color: #800000;">CrawledProperty</span> <span style="color: #ff0000;">propertySet</span><span style="color: #0000ff;">="fa585f53-2679-48d9-976d-9ce62e7e19b7"</span> <span style="color: #ff0000;">varType</span><span style="color: #0000ff;">="31"</span> <span style="color: #ff0000;">propertyName</span><span style="color: #0000ff;">="concepts"</span><span style="color: #0000ff;">/&gt;</span>   <span style="color: #0000ff;">&lt;/</span><span style="color: #800000;">Output</span><span style="color: #0000ff;">&gt;</span><span style="color: #0000ff;">&lt;/</span><span style="color: #800000;">Run</span><span style="color: #0000ff;">&gt;</span>

In PowerShell you have the option to instantiate any .Net object, and for this script I use the XmlDocument class for xml creation out the result file. The script is pretty straight forward as it reads in an xml file. Selects a property called “docvector” and writes this out to a new field called “concepts”.  Typically you would do more work than just copy an attribute, but it shows the concept.

I’m not a PowerShell expert, so there might be better ways of doing some parts of this script. Make a note that I read and write the xml files with UTF-8 encoding. This is crucial as this is what the pipeline works with.

concept.ps1

function CreateXml()
{
	param ([string]$set, [string]$name, [int]$type, $value)

	$resultXml = New-Object xml
	$doc = $resultXml.CreateElement("Document")

	$crawledProperty = $resultXml.CreateElement("CrawledProperty")
	$propSet = $resultXml.CreateAttribute("propertySet")
	$propSet.innerText = $set
	$propName = $resultXml.CreateAttribute("propertyName")
	$propName.innerText = $name
	$varType = $resultXml.CreateAttribute("varType")
	$varType.innerText = $type

	$crawledProperty.Attributes.Append($propSet) > $null
	$crawledProperty.Attributes.Append($propName) > $null
	$crawledProperty.Attributes.Append($varType) > $null

	$crawledProperty.innerText = $value

	$doc.AppendChild($crawledProperty) > $null
	$resultXml.AppendChild($doc) > $null
	$xmlDecl = $resultXml.CreateXmlDeclaration("1.0", "UTF-8", "")
	$el = $resultXml.psbase.DocumentElement
	$resultXml.InsertBefore($xmlDecl, $el) > $null

	return $resultXml
}

function DoWork()
{
	param ([string]$inputFile, [string]$outputFile)
	$propertyGroupIn = "48385c54-cdfc-4e84-8117-c95b3cf8911c" # FAST internal group
	$propertyNameIn = "docvector" # property name
	$dataTypeIn = 31 # integer

	$propertyGroupOut = "fa585f53-2679-48d9-976d-9ce62e7e19b7" # Custom group
	$propertyNameOut = "concepts" # property name
	$dataTypeOut = 31 # integer

	$xmldata = [xml][/xml][/xml]

(Get-Content $inputFile -Encoding UTF8) 	$node = $xmldata.Document.CrawledProperty | Where-Object {  $_.propertySet -eq $propertyGroupIn -and  $_.propertyName -eq $propertyNameIn -and $_.varType -eq $dataTypeIn } 	$data = $node.innerText  	# do your custom modification on $data here  	$resultXml = CreateXml $propertyGroupOut $propertyNameOut $dataTypeOut $data 	$resultXml.OuterXml | Out-File $outputFile -Encoding UTF8 } DoWork $args[0] $args[1]

[Originally postet at http://techmikael.blogspot.com/2011/03/prototyping-pipeline-stages-in.html]

As described on TechNet:

Best Bets are recommended results. Best Bets can link to recommended Web sites, data stores, and documents. When a user includes a keyword or one of its synonyms in a query, the search results page features links to its associated Best Bets in a prominent position.

This can look something like this for the search term “search” on my sample site:

In order to turn this into a landing page redirect we will change the uri scheme and edit the Best Bet web part xslt. By using this method you might see a quick flicker of the page before the redirect, but compared to the work involved it might be a small price to pay.

First we need to add a new Best Bet term. We do this by navigating to the site collection settings page where your search center site is hosted and choose “FAST Search keywords”. This should also work if you are not using FAST, but you have to choose “Search keywords” instead.

Next click “Add Keywords”

Enter your search term, in this example “search” and click OK.

Hover your mouse over your search term, click the down arrow and select the “Add Best Bet” link. (Adding a Best Bet for regular search looks a bit different, but the procedure is more or less the same)

Enter a title and note that I instead of “http”, enters “redirect” in front of the url

Navigate to the search result page and enter edit mode. Next edit the Best Bet web part.

Under “Data View Properties” open the XSL Editor. If you copy out the xsl you will around line 67 add the following code:

<span class="kwrd">&lt;</span><span class="html">xsl:if</span> <span class="attr">test</span><span class="kwrd">="substring($url,1,9) = 'redirect:' and $IsDesignMode = 'False'"</span><span class="kwrd">&gt;</span>
    <span class="kwrd">&lt;</span><span class="html">script</span><span class="kwrd">&gt;</span>
         window.location = <span class="str">"http:&lt;xsl:value-of disable-output-escaping="</span>yes<span class="str">" select="</span>srwrt:HtmlAttributeEncode(substring($url,10))<span class="str">" /&gt;"</span>;
    <span class="kwrd">&lt;/</span><span class="html">script</span><span class="kwrd">&gt;</span>
<span class="kwrd">&lt;/</span><span class="html">xsl:if</span><span class="kwrd">&gt;</span>

The added xsl will check for url’s starting with “redirect”, and use javascript to redirect to the actual url.

After saving the changes to the web part and the page, try to search for your defined best bet term, and you should be redirected.

One way is to create a custom master page to replace v4.master for the search center, but this requires html knowledge and tinkering. In many cases it’s just as easy to go the configuration way.

Hello IsDlg=1and s4-notdlg

You have probably seen throughout SharePoint 2010 that it opens modal dialogs for different tasks. For example if you want to create a new site you get a dialog looking something like this

The source for this page is loaded from /_layouts/AddGallery.aspx?IsDlg=1

The part to note is the appending of IsDlg=1 which tells the page it is rendered in a modal dialog. In effect this will change some styles for the page which hides the ribbon and top menus based on the style sheet class s4-notdlg. (MSDN: http://msdn.microsoft.com/en-us/library/microsoft.sharepoint.webcontrols.unsecuredlayoutspagebase.isdialogmode.aspx).

In order for a page to frame in search they will merely append IsDlg=1 to the search center url.

Unfortunately the IsDlg=1 parameter is not added automatically to all links. There are a couple of places we need to edit.

First off is the  Advanced link. Edit the search page and append IsDlg=1& to the link

After saving switch over to the People search box and do the same edit for the people search result page.

In theory we could add ?IsDlg=1 to the result page link as well, but this won’t work as ?k=searchterm is added in front of it, and two question marks in the url messes up the parsing.

Instead we modify the xslt for the result pages by a small style sheet entry.

<span style="color: #0000ff;">&lt;</span><span style="color: #800000;">xsl:text</span> <span style="color: #ff0000;">disable-output-escaping</span><span style="color: #0000ff;">="yes"</span><span style="color: #0000ff;">&gt;</span>     <span style="color: #0000ff;">&lt;!</span>[CDATA[    <span style="color: #0000ff;">&lt;</span><span style="color: #800000;">style</span> <span style="color: #ff0000;">type</span><span style="color: #0000ff;">="text/css"</span><span style="color: #0000ff;">&gt;</span>    .s4-notdlg { display: none !important }    <span style="color: #0000ff;">&lt;/</span><span style="color: #800000;">style</span><span style="color: #0000ff;">&gt;</span>    ]]<span style="color: #0000ff;">&gt;</span><span style="color: #0000ff;">&lt;/</span><span style="color: #800000;">xsl:text</span><span style="color: #0000ff;">&gt;</span>

This can be places below <xsl:template match=”/”>  at the end of the default xslt. Do the same for the xslt on the people search result page.

The caveat with setting the s4-notdlg style is that it will hide the ribbon menus regardless of the IsDlg query parameter. This leads us to have one search center for framing and one which is used natively in SharePoint 2010.

So the question remains, is it better to rely on IsDlg and s4-notdlg or should I go for a custom master page?