Search Nuggets » Mikael Svenson

Deleting a Federated Location via the API

Mikael Svenson — Wed, 22 Jun 2011 12:51:00 +0000

I’m working on a SharePoint feature which will automatically add a federated search location on feature activation and which will delete it on de-activation.

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.

public class DynamicReflectionHelperforObject<V>{
    public delegate T GetPropertyFieldDelegate<T>(V obj);

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

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

And to use it pass inn the object type, the property type and the object we want to retrieve the property from:

int id = Helpers.DynamicReflectionHelperforObject<LocationConfiguration>
   .GetProperty<int>("Id")
   .Invoke(frontLocation);
fastQuerySSA.DeleteLocationConfiguration(id);

Document Thumbnails and PowerPoint Preview for your search results without installing FAST for SharePoint

Mikael Svenson — Sat, 14 May 2011 11:17:20 +0000

[Originally posted at: http://techmikael.blogspot.com/2011/05/document-thumbnails-and-powerpoint.html]

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.

Working with crawled and managed properties via code

Mikael Svenson — Wed, 04 May 2011 20:52:13 +0000

I was teaching a FAST for SharePoint Workshop today and we were doing labs on creating and mapping crawled properties to managed properties with the FAST Administration UI and via PowerShell. But one student wanted to know how to do this in code, hence this blog post.

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);

}

Three Main Reasons Why You Should Upgrade to FAST for SharePoint

Mikael Svenson — Mon, 02 May 2011 19:23:04 +0000

I was fortunate to be one of three finalists in SharePoint Magazine’s Aspiring Author Contest. Today the article went live and I’m quite happy about it.

You can read the article over at SharePoint Magazine, and if you like it feel free to click the Facebook Like button at the end.

The other two finalists are:

“Best Practices for SharePoint Groups” by Josh McCarty and “A Guide to Leaving Lotus Notes and Moving to Microsoft SharePoint” by Andrew Vevers.

And if you are serious about search within SharePoint, go FAST!

Adding new nicknames to SharePoint People Search

Mikael Svenson — Thu, 28 Apr 2011 13:49:06 +0000

Out of the box SharePoint 2010 comes with a pretty good people search. This is due to a combination of phonetic rules and a vast list of nicknames. Out of the box the US English nickname list consists of over 14.000 nickname mappings, ensuring good results when trying to find people.

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.

DateTime resolution for querying FAST for SharePoint

Mikael Svenson — Thu, 14 Apr 2011 11:34:55 +0000

I was doing range queries in the Search Center UI to limit documents between two exact dates.

But no matter what I entered as hours/minutes/seconds in my query I still got the same result.

There are good and bad news around this. The good news is that you can change the resolution from day to for example hours for your default rank profile:

$rank = Get-FASTSearchMetadataRankProfile
$rank.FreshnessResolution = “Hour”
$rank.Update()

The bad news is that the Search Center UI disregards this, and when monitoring the queries received by FAST all hours/minutes/seconds are stripped from the query. They are adjusted for time zones as you can see below where 00:00:00 is turned into 23:00:00 of the day before the original query.

If you want to do date range queries on an interval less than a day you have to use the development API’s, and not the default Search page.

Why you still should prefer PowerShell over UI to create Search Scopes in FAST for SharePoint

Mikael Svenson — Wed, 30 Mar 2011 07:40:00 +0000

When SharePoint 2010 came out the only way to create a search scope was to do it by PowerShell. Well, you could create the scope name itself via Central Admin, but the actual scope filter had to be done via PowerShell.

If you picked up on what changes in the Cumulative SharePoint 2010 updates you might have noticed that the August 2010 release changed this.

When you create a search scope by using FAST Search, you have to have a scope filter that matches the scope rules attached to the search scope. However, the scope filter is empty and must be set manually by using PowerShell when you create a new search scope.

But it’s not necessarily that easy. For every managed property you might have defined for FAST, you have to create a shadow copy/placeholder which you can use in your scope. There is a 9 step list at TechNet outlining the procedure. Also the GUI limits you to filter on web address or a specific property, much like the keyword syntax in the search page.

By using PowerShell you have the full force of fql at your disposal, and no need to create placeholder properties. For example the following query will boost documents from a particular site, and from a particular department to the top of the list.

xrank(path:starts-with(“http://site/”),escdeptname:ends-with(“1200″), boost=10000)

It’s nice that GUI support is added, but I will still stick to PowerShell for scopes for the time being :-)

[Originally posted at: http://techmikael.blogspot.com/2011/03/why-you-still-should-prefer-powershell.html]

Prototyping pipeline stages in PowerShell

Mikael Svenson — Wed, 02 Mar 2011 10:56:10 +0000

The defacto way of creating a custom pipeline stage in FAST for SharePoint is to create an executable file which reads and writes an xml file. This usually implies having Visual Studio available and compiling and deploying a new file each time you make a change in order to test it in a proper pipeline.

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

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

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]

Using the SharePoint Search “Best Bet” feature to redirect to a landing page

Mikael Svenson — Sat, 19 Feb 2011 11:14:00 +0000

[Cross-posted from Tech And Me]

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:

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

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.

How to: Frame a search center with little work

Mikael Svenson — Thu, 27 Jan 2011 13:05:00 +0000

Lately I have encountered several customs who deploy search from SharePoint 2010, but they still have other solutions running on MOSS 2007 or other portal frameworks. Instead of creating custom solutions using the search service on SharePoint 2010, framing is a quick solution to get you up and running.

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.

<xsl:text disable-output-escaping="yes">     <![CDATA[    <style type="text/css">    .s4-notdlg { display: none !important }    </style>    ]]></xsl:text>

This can be places below 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?