That said, here is my disclaimer to go with this post:

 These tools are not created or maintained by me. I use / have used all of these personally, but always with caution. I am in no event responsible or liable for any damages whatsoever arising out of or related to the tools listed here.

•  Read the documentation often included in the tools package or listed on the authors site.
• Test the tools on your own, controlled environment.
• In case of questions, check with the author’s site. They usually have sections dedicated to questions and comments and are your best option for getting answers.

 I labelled them according to the following categories:

The tools, in no particular order:

ULS Viewer	Diagnose, Maintain	Link
	ULSViewer allows users to open a ULS log file and display its contents in a user friendly format. Users can then perform advanced functions such as filtering, sorting, highlighting, loading logs, appending logs, etc in order to single out the data that is important to the user. This information can be used to diagnose problems with machines running ULS services, or to monitor machines and the events they create in realtime.
Fiddler	Diagnose	Link
	Fiddler is a free web debugging proxy which logs all HTTP(s) traffic between your computer and the Internet. Use it to debug traffic from virtually any application that supports a proxy like IE, Chrome, Safari, Firefox, Opera, and more.
C2WTS Test	Diagnose	Link
	Application to assist in troubleshooting the Claims to Windows NT Token Service.
Log Parser Studio	Diagnose, Maintain	Link
	Log Parser Studio is a utility that allows you to search through and create reports from your IIS, Event, EXADB and others types of logs. It builds on top of Log Parser 2.2 and has a full user interface for easy creation and management of related SQL queries.
Kerbtray	Diagnose	Link
	Kerbtray is part of the Windows Server Resource Kit Tools. It runs from the system tray and provides usefull Kerberos information.
SPDisposeCheck	Develop, Diagnose	Link
	SPDisposeCheck is a tool that helps developers and administrators check custom SharePoint solutions that use the SharePoint Object Model helping measure against known Microsoft dispose best practices. This tool may not show all memory leaks in your code and may produce false positives which need further review by subject matter experts.
Microsoft SharePoint Online Code Analysis Framework MSOCAF	Develop, Diagnose	Link
	By using MSOCAF, the engineering review process should be expedited as the customers will be able to detect and fix the code issues themselves before submitting the custom solutions to Microsoft. Optionally, MSOCAF can also be used to deploy custom solutions to the customer’s test environment or to rollback or remove components of a deployed solution. Previously the submission process was manual and thus time consuming. MSOCAF can communicate with a web service hosted on the customer’s SharePoint environment to submit the deployment package, and submit the custom solution automatically.
SPCAF	Develop, Diagnose	Link
	Essential tool to ensure SharePoint code quality. SPCAF analyzes SharePoint code from .wsp and .app files and checks all contained code incl. XML for correctness, best practices etc. It also creates dependency Graphs, calculates code metrics and creates an inventory.
Snap	Develop, Diagnose	Link
	Captures a stack trace of the managed stack for each thread within a process and writes the output into a XML log file on disk. Each “Snap” results in an XML log file and can have the snap interval, max snap count, or duration configured.
Chrome Developer Tools	Develop	Link
	The DevTools, bundled in Chrome, provide web developers deep access into the internals of the browser and their web application. This overview of the Developer Tools points out its most popular and useful features. The target audience are web developers who don’t know of, or have not yet investigated, the DevTools. However, we are sure that even if you are an experienced web developer, you will pick up some tips.
Firefox Firebug	Develop	Link
	Firebug integrates with Firefox to put a wealth of development tools at your fingertips while you browse. You can edit, debug, and monitor CSS, HTML, and JavaScript live in any web page…
Internet Explorer Developer Tools	Develop	Link
	Every installation of Internet Explorer comes with the Developer Tools. This tool enables Web site developers to quickly debug Microsoft JScript, investigate a behavior specific to Windows Internet Explorer, or iterate rapidly to prototype a new design or try solutions to a problem on-the-fly.
Yslow	Diagnose, Develop	Link
	YSlow analyzes web pages and suggests ways to improve their performance based on a set of rules for high performance web pages. http://yslow.org is the official open source website.
SSL Diagnostics	Diagnose	Link
	The SSL Diagnostics tool is a very useful tool for troubleshooting SSL issues. It generates a detailed report of SSL settings for all the websites on an IIS server which helps in quickly identifying SSL issues. But the tool was built for IIS 5 and 6, there is no version available which is compatible with IIS 7. The SSL Diagnostics tool does succeed in generating a report on IIS 7 if the IIS 6.0 Metabase Compatibility feature is installed. To help troubleshoot SSL issues on IIS 7 I have written a tool which works in a similar fashion. It scans all the websites and FTPS sites configured on the server and generates a report which can help in identifying SSL issues.
AutoSPInstaller	Deploy	Link
	Automated SharePoint 2010/2013 PowerShell-based installation script.
AutoSPSourceBuilder	Deploy	Link
	AutoSPSourceBuilder: a utility for building a SharePoint 2010 / 2013 install source including prerequisites, service packs, language packs & cumulative updates.
AutoSPInstaller GUI	Deploy	Link
	AutoSPInstallerGUI is a GUI Configuration Tool for AutoSPInstaller Codeplex Project.
HP Sizer for Microsoft SharePoint	Design	Link
	HP Sizer for Microsoft SharePoint is a complimentary planning resource that encapsulates knowledge gained from extensive performance characterization of Office SharePoint Server 2007 and SharePoint 2010 in the HP Alliances Performance and Solutions labs, widespread collaboration between HP and Microsoft, and numerous SharePoint performance whitepapers produced by HP engineering. The Sizer offers a quick and consistent methodology for determining and comparing configurations, as well as detailed, customizable server and storage solutions complete with bill of materials and pricing.
SPDocKit	Deploy, Maintain	Link
	After the installation of Microsoft SharePoint software on the server / farm, you need to create a proper documentation file containing system and configuration settings. That type of document is essential for SharePoint administrators in order to provide support and maintenance of the installed environment. Documentation Toolkit for SharePoint performs that task with only a few mouse clicks. It saves hours of manually pasting data from different sources into the documentation file. This product automatically generates MS Word (docx) document with all configuration settings.
Termstore Creator	Design	Link
	The Term Store Manager allows you to import a comma separated text file containing a Term Set. By default the Excel 2010 Save as CSV does not save in the correct format and for that I have made a Excel 2010 macro enabled template which produces the correct format.
Membership Seeder	Design	Link
	If you need to setup large amounts of test accounts for your Form Based Auth environment, the Membership Seeder tool can help you out.
Feature Admin	Maintain	Link
	The Feature Admin Tool finds faulty FeatureDefinitions and cleanly uninstalls them. It finds feature remainders in sites, SiteCollections, WebApps and in the Farm, caused e.g. by forcefully uninstalled Features from a farm without deactivating them before. These faulty features, never visible, cause errors. The Feature Admin Tool is able to identify them and remove them.
CKS DEV	Develop	Link
	The CKS – Development Tools Edition for Visual Studio 2012 is a collection of Visual Studio templates, Server Explorer extensions and tools providing accelerated SharePoint 2010/2013 development based on Microsoft’s SharePoint 2010/2013 development tools.

Basically, how this works is, you send a special ‘resize’ message to your iFrames parent (the SharePoint Web containing the App Part). Based on this message, the iFrame is resized according to the supplied dimensions:

window.parent.postMessage(“<message senderId={your ID}>resize(120, 300)</message>”, this.location.hostname);

This only works if your Client Web Parts have the Web Part Title enabled (via the Client Web Part Chrome settings). If you don’t, the resizing function breaks, because it cannot find the Web Parts title DIV:

SCRIPT5007: Unable to get property ‘style’ of undefined or null reference

The code throwing the error:

if (resizeWidth)
{
document.getElementById(webPartDivId + '_ChromeTitle').style.cssText = widthCssText;
cssText = 'width:100% !important;'
}

Unfortunately, there is not much we can do about this. If you really need the App Part title gone and keep the dynamic resizing my choice would be to hide it using CSS. Meanwhile we wait for the fix.

Themes in SharePoint 2013 consist of two things:

• A theme, as in colorscheme
• Optionally a fontscheme

Furthermore, a theme is part of what is called a “Composed Look”. These Composed Looks are essentially what is available to you when you click the “Change the look” under Site Settings.

Besides a color- and fontscheme the following items are part of a composed look:

• A master page, this can also be a custom master page
• Optionally a background image

The solution

Things I like to have changed in my custom look:

1. Some UI colors for specific elements, in this case the SuiteBar at the very top
2. Some of the fonts used
3. Add a custom background image

In the end, it should look like this:

I like the default look, but also want to include a background image. This default look is called the Office Look and it doesn’t use any specific font. For fonts, I favour the one used for “Sea Monster”. BTW, don’t you love that theme’s name? If you want to take a look at all the different OOTB themes, take a peek under “Change the look” in your site settings.

Most of these tasks can be done through the UI by uploading the artifacts manually. In this case (and almost any case) I like to use Visual Studio to ensure the correct deployment of these files. Theming, at least for me, is usually done for on premise or dedicated SharePoint solutions, so I don’t mind creating Farm solutions for this task.

Since the schema is pretty important, it is best to start with some of the OOTB parts:

1. First we copy the color pallette used by the Office Look, since we like most of this OOTB theme
2. Then we copy the fonts used by Sea Monster
3. And finally grab your custom background logo. Make sure you keep the size of this file under 150KB!

You can download the color palette and fontscheme from the links in the “Composed Looks” settings section.

To set this up using Visual Studio 2012, we create a new Solution and make it a Farm Solution.

Next, we add a mapped “Images” folder for our background image.

Then, we add a module (or two if you are including a custom master page) to deploy our Theme and Fontscheme. Add the artifacts and rename them appropiately (companylook-palette001.spcolor and companylook-fontscheme001.font in my case)
Modify the elements.xml so we deploy to the correct catalogs. Don’t forget to add GhostableInLibrary attribute!

This table lists the possible deployment options for our artifacts:

Note: The attribute Type=”GhostableInLibrary” indicates that the item is added to the content database. The Url attribute of the module specifies where to store the file in the content database.

This is what your solution structure should look like right now:

To create a “Composed Look” we actually need to insert a listitem in the “Composed Looks” list. To do this we use a Feature Receiver that adds the list item with the correct field values:

Add a feature receiver to our solution’s feature. Set the scope to “Web”

Then add the following code to insert our custom list item:

public override void FeatureActivated(SPFeatureReceiverProperties properties)
        {
            var web = properties.Feature.Parent as SPWeb;
            var list = web.GetList(string.Format("{0}/_catalogs/design",web.ServerRelativeUrl));
            var item = list.AddItem();

            item["Title"] = "CompanyLook";
            item["Name"] = "CompanyLook";
            item["DisplayOrder"] = 1;

            var masterPageUrl = new SPFieldUrlValue();
            masterPageUrl.Url = masterPageUrl.Description = "/sites/dev/_catalogs/masterpage/seattle.master";
            item["MasterPageUrl"] = masterPageUrl;

            var themeUrl = new SPFieldUrlValue();
            themeUrl.Url = themeUrl.Description = "/sites/dev/_catalogs/theme/15/companylook-palette001.spcolor";
            item["ThemeUrl"] = themeUrl;

            var fontSchemeUrl = new SPFieldUrlValue();
            fontSchemeUrl.Url = fontSchemeUrl.Description = "/sites/dev/_catalogs/theme/15/companylook-fontscheme001.spfont";
            item["FontSchemeUrl"] = fontSchemeUrl;

            var imageUrl = new SPFieldUrlValue();
            imageUrl.Url = imageUrl.Description = "/_layouts/15/images/CompanyLook/Background.png";
            item["ImageUrl"] = imageUrl;

            item.Update();
        }

Remember to set the DisplayOrder, otherwise you will get the default value of 100 and your look will be hidden behind the “Grey” look.

This takes care of the deployment of our custom theme. Site owners can now activate it using the site settings, but you can also do it using code behind with another feature receiver.

Add a feature and feature receiver to our solution. Again, set the scope to “Web”. Add the following code to activate the custom look:

 public override void FeatureActivated(SPFeatureReceiverProperties properties)
        {
            var web = properties.Feature.Parent as SPWeb;
            var list = web.GetList(string.Format("{0}/_catalogs/design", web.ServerRelativeUrl));

            SPQuery query = new SPQuery();
            query.ViewFields = "<FieldRef Name='ThemeUrl' /><FieldRef Name='ImageUrl' /><FieldRef Name='FontSchemeUrl' />";
            query.Query = "<Where><Eq><FieldRef Name='Name' /><Value Type='Text'>CompanyLook</Value></Eq></Where>";

            SPListItemCollection listItems = list.GetItems(query);

            if (listItems.Count >= 1)
            {
                var theme = new SPFieldUrlValue(listItems[0]["ThemeUrl"].ToString());
                var font = new SPFieldUrlValue(listItems[0]["FontSchemeUrl"].ToString());
                var image = new SPFieldUrlValue(listItems[0]["ImageUrl"].ToString());

                if (theme != null && font != null && image != null)
                {
                    // In production code, make sure the files exist before applying the theme!
                    var themeUrl = (new Uri(theme.Url)).AbsolutePath;
                    var fontSchemeUrl = (new Uri(font.Url)).AbsolutePath;
                    var imageUrl = (new Uri(image.Url)).AbsolutePath;

                    web.ApplyTheme(themeUrl, fontSchemeUrl, imageUrl, true);
                }
            }
        }

That’s it! You can download the complete Visual Studio 2012 solution here.

Creating Sustainable Solutions With SharePoint 2013

Creating sustainable solutions is always daunting, whether you are a single developer or working as a member in a large team. Every type of project requires a specific approach, there are no silver bullets. Still, there are some considerations you should make with every new SharePoint development project to ensure proper developer workflow and the delivery of maintainable solutions.
In this session we will look at several new tools and topics around SharePoint 2013 and Team Foundation Server 2012 and how you can use them to enhance your development projects.
Topics covered:
• The correct SharePoint solution type
• Solution Lifecycle Management
• TFS supported development
• Quality Assurance

Download my slide deck here: Yuri-BurgerSustainable Solutions with SharePoint 2013

To view a listing of all available slide decks from SPC Amsterdam 2012, visit the SPC site here.

1. There is no definite checklist for deploying SharePoint for the Internet. Every project is different and there are no silver bullets. In fact, it is not even a real checklist (just a list of items I’d like to consider on every internet project).

2. This is my checklist based on experiences with past projects, your mileage may (and will) vary  

3. There are so many options and configurations possible, it is not just about enabling/disabling features and options to achieve your goal. Every option should be investigated thoroughly and remember: ‘Just because you can, doesn’t mean you should’. 

Since there many options to consider, I divided them in three main categories and three separate blog posts:

• Part 1: Performance (this post)
• Part 2: Security
• Part 3: Customization and usability

Performance

Big topic for internet facing websites. While SharePoint 2010 performs a lot better compared to previous versions, performance will (and should) always be on your list.

#1: Reduce page load

• Remove the “Name Active X Control”. This control is used by SharePoint to show presence information (the little icon next to author names, etc.) and has no meaning on public (anonymous) web sites. You can do this through Central Administration (Web Application General Settings:

• Remove the reference to the SharePoint Workspace ActiveX from the master page (present if based on the OOTB master pages).
• Limit the use of Content Query Web Parts on landing pages. While this is a beautiful Web Part, it adds significantly to the page load time especially initially with uncached data. As a workaround you could use custom developed web parts or user controls to achieve your data query goals. This way you have good control of the rendered HTML and avoid the XSLT query processing part. But make sure you have some kind of caching in place.
• Remove the Ribbon for anonymous users. There are a couple of ways to do this, these are the most obvious ones:

• Minify jQuery and other 3rd party JavaScript libraries. Use a CDN if applicable for the libraries since this facilitates caching by browser, proxy server, etc. Remember to enable local fail-over copies.

#2: Monitor Page Requests

• Use a network monitor or traffic inspector (like Fiddler2) to monitor the HTTP request and response associated with a page request. These type of tools make optimizing page loads a whole lot easier.
• Use the SharePoint Developer Dashboard to monitor processing and render times of individual components.

#3: Adjust IIS Dynamic Compression

• By default SharePoint Web Servers have static and dynamic file compression enabled, but the compression level for dynamic files is set to “0”. This means that dynamic files don’t get compressed at all. You can adjust the compression level and the CPU threshold settings, for more information see Technet. It is not just about enabling this, you will have to monitor performance and Web Server CPU for tuning adjustments.

#4: Caching

SharePoint 2010 and the underlying ASP.NET offer several different methods for caching. Again no silver bullets here, and my advice: develop a caching strategy! The way you configure the different caching options totally depends on the type of content served (static versus dynamic), the audience, intended web site usage and so on. Make a note on what type of cache you configure, how you configure it and what results you expect. Once you start monitoring your site’s performance you can easily check and adjust where needed.

More info on this topic, see Technet.

• The BLOB cache. BLOB stands for Binary Large OBject and is a disk based storage. Files initially retrieved from the SharePoint Content Database are stored on disk and served to clients on subsequent requests. You need to think about what type of files to store, where to store them (on the web server) and what client cache life time to configure (max-age).
• The Object cache. If you are using SharePoint’s publishing feature (and you probably are on internet facing sites), you can configure this cache. The cache stores SharePoint objects (lists, page layouts, etc.) in-memory to speed up queries on them. They require the correct configuration of what is called the “Object Cache User Accounts”, again see Technet for more information.
• Output cache. Based on ASP.NET Output Caching, but with added features (which also require the SharePoint publishing feature). Usually the least popular of the three, probably because it is a little bit harder to configure correctly. There are a couple of considerations to make, so definitely take a look at the Technet article.

Please, feel free to comment on this topic, more coming soon.

More info on the Lockdown feature on this MSDN blog (MOSS 2007, but still applicable. By Ryan Duguid)

As we all know, SharePoint 2010 includes the Health Analyzer. This component uses a bunch of rules to check the farm for predefined issues and report on any found:

Fortunately, the rule set is extensible and we can add our custom ones. This is not a difficult task and a good candidate for our feature check!

To start we need to create a class that inherits from either the SPHealthAnalysisRule or SPRepairableHealthAnalysisRule. From these abstract classes we need to implement some string properties “Summary”, “Explanation” and “Remedy” (for explaining the issues found) and the “Category” and “ErrorLevel” properties. The “Check()” method performs the actual analysis so must be implemented too. If you want users to be able to execute a repair right from the Central Administration interface, the SPRepairableHealthAnalysisRule includes a “Repair()” method just for that. Finally we can implement the “AutomaticExecutionParameters” property to enable automatic Timer Job execution for our rule and in this case we do.

More detailed info on this on MSDN.

1. We start with an Empty SharePoint Project, and deploy it as a Farm Solution. We add our Central Administration web as our Site Url.

2. Next we add the class that inherits from SPHealthAnalysisRule and add the necessary using statements. After implementing the abstract class our rule looks like this:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.SharePoint;
using Microsoft.SharePoint.Administration;
using Microsoft.SharePoint.Administration.Health;

namespace Blog.Examples.HealthAnalysisRule
{
     public sealed class ViewFormPagesLockDown : SPHealthAnalysisRule
    {
        public override SPHealthCategory Category
        {
            get { throw new NotImplementedException(); }
        }

        public override SPHealthCheckStatus Check()
        {
            throw new NotImplementedException();
        }

        public override SPHealthCheckErrorLevel ErrorLevel
        {
            get { throw new NotImplementedException(); }
        }

        public override string Explanation
        {
            get { throw new NotImplementedException(); }
        }

        public override string Remedy
        {
            get { throw new NotImplementedException(); }
        }

        public override string Summary
        {
            get { throw new NotImplementedException(); }
        }
    }
}

3. Next we add our logic to the Check() method to do the actual testing. This method uses two helper functions, both included in the downloadable solution:

• isAnonymousEnabled: checks if the Web Application has Anonymous Access turned on.
• isFeatureActivated: checks if the FormPagesLockDown feature is activated.

The method itself stores any failing Web Application and a counter which we can use for reporting the issues.

public override SPHealthCheckStatus Check()
{
            SPHealthCheckStatus ret = SPHealthCheckStatus.Passed;
            SPFarm farm = SPFarm.Local;
            foreach (SPService service in farm.Services)
            {
                if (service is SPWebService)
                {
                    SPWebService webService = (SPWebService)service;
                    foreach (SPWebApplication webApp in webService.WebApplications)
                    {
                        if (isAnonymousEnabled(webApp))
                        {
                            foreach (SPSite site in webApp.Sites)
                            {
                                try
                                {
                                    if (!isFeatureActivated(site, new Guid(FEATUREGUID)))
                                    {
                                        //Anonymous Access is enabled on the Web Application, but the ViewFormsLockDown feature was not found.
                                        this.failingWebApplications.Add(webApp.Name, +1);
                                    }
                                }
                                finally
                                {
                                    if (site != null)
                                    {
                                        site.Dispose();
                                    }
                                }
                            }
                        }
                    }
                }
            }
            if (this.failingWebApplications.Count == 0)
            {
                ret = SPHealthCheckStatus.Passed;
            }
            else
            {
                ret = SPHealthCheckStatus.Failed;
            }
            return ret;
 }

4. Finally implement the property “SPHealthAnalysisRuleAutomaticExecutionParameters” to enable automatic Timer Job schedules.

public override SPHealthAnalysisRuleAutomaticExecutionParameters AutomaticExecutionParameters
{
            get
            {
                SPHealthAnalysisRuleAutomaticExecutionParameters retval = new SPHealthAnalysisRuleAutomaticExecutionParameters();
                retval.Schedule = SPHealthCheckSchedule.Daily;
                retval.Scope = SPHealthCheckScope.All;
                retval.ServiceType = typeof(SPTimerService);
                retval.RepairAutomatically = false;
                return retval;
            }
 }     

5. We now could build and deploy, but we would have to register the custom Health Analyzer rules through PowerShell. This process can be automated through SharePoint’s feature framework.

 public override void FeatureInstalled(SPFeatureReceiverProperties properties)
 {
            try
            {
                Assembly currentAssembly = Assembly.GetExecutingAssembly();
                IDictionary exceptions = SPHealthAnalyzer.RegisterRules(currentAssembly);
            }
            catch (Exception ex)
            {
                throw new Exception("There was an error registering the Health Analysis rules: " + ex.Message); 
            }
}

If we compile and deploy, we can see our rule in action.

If you want the rule to report any errors, make sure you enable anonymous access on a Web Application and disable the (hidden) feature. Of course we should use PowerShell for this:

Disable-SPFeature -Identity ViewFormPagesLockDown -Url http://public.demo.loc

Download the complete solution here.

By default this score is calculated using two performance counters: Memory/Available Mbytes and ASP.NET/Requests Current. A value “0” indicates everything is fine, while a value of “10” indicates SharePoint will start throttling requests (if enabled). There is quite some info around explaining the workings and configuration. This blog post for instance: http://blogs.msdn.com/b/besidethepoint/archive/2010/09/13/http-request-throttling-in-sharepoint-2010.aspx (by Josh Gavant).

Since this header is added to every response it can be used for different purposes, from monitoring to load balancing. I wanted to create a small “tool” to report the score without having to use a network monitor or HTTP sniffer like Fiddler. And what better way than to use PowerShell for this task?

The script uses a simple PowerShell function with a System.Net.WebClient object connecting to a SharePoint site and retrieving the header:

function ReadHealthScore()
{
	param([string]$url,[System.Net.NetworkCredential]$cred=$null)
	
	$wc = New-Object Net.WebClient
	
	# Include the IE9 User Agent
	$wc.Headers.Add("user-agent", "Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Trident/5.0;)")

	if($cred -eq $null)
	{
		$cred = [System.Net.CredentialCache]::DefaultCredentials;
	}
	$wc.credentials = $cred;
	$page = $wc.DownloadString($url);
	
	# This header holds the Health Score
	return $wc.ResponseHeaders.Item("X-SharePointHealthScore")
}

Combined with some logic to calculate average, minimum and maximum:

# Wait in number of seconds
$wait = 1
$times = 5
$score = @()

# Set the URL to a page to avoid redirection errors
$url = "http://portal.demo.loc/Pages/Default.aspx"

for ($i=1; $i -lt $times+1; $i++) {
 	$score = $score + (ReadHealthScore($url))
	Write-Progress -Activity "Reading HealthScore" -PercentComplete (($i/$times)*100) -Status "Working"
  	Start-Sleep -Seconds $wait
}

$calc = $score | Measure-Object -Average -Maximum -Minimum
Write-Host (Get-Date -f o) "Average:"$calc.Average " High:"$calc.Maximum " Low:"$calc.Minimum

We get the following output:

With a little modification you can output to xml or CSV. Schedule it using Task Scheduler and you will have a nice little health reporter.

Download the script here.

Note: since this script doesn’t use any specific SharePoint cmdlets, you can use standard Windows PowerShell.

SharePoint 2010 Enterprise Search uses ranking models to determine how data is weighed and results are ranked. Out of the box SharePoint 2010 provides different models, but you can also create your own. Creating your own ranking model allows you to tailor the results your query returns by:

• assigning different weights to metadata properties.
• include hits on custom managed properties in general search (as opposed to searching them through advanced search exclusively).

There are several nice blogs out there that describe in detail how you can add your own custom ranking model. For instance this excellent blog post, which describes the process quite clear: http://calvisblog.wordpress.com/2010/06/21/custom-ranking-models-with-sharepoint-2010-background-value-and-administrative-overview/ (by Shaun O’Callaghan).

Applying your custom ranking model requires you to look up the GUID, export the standard OOB Core Results Web Part, modifying a web part property and uploading it again (see this previous post). Now, that works of course, but I wanted a true end-user solution where you can configure the ranking model through the web part properties. Something like this:

Extending the Core Results Web Part

Note: we need to develop a SharePoint Farm Solution, because the Microsoft.SharePoint.WebPartPages.DataFormWebPart class (referenced
by the CoreResultsWebPart) is not available in sandbox solutions.

To start, we create a new web part deriving from the Core Results Web Part. The web part includes a property that allows setting the RankingModelID. It also inherits from IWebEditable needed for implementing an EditorPart (see further down).

public class EnhancedCoreResults : CoreResultsWebPart, IWebEditable
{
     [WebBrowsable(false)]
     [Personalizable(PersonalizationScope.Shared)]
     public string rankingModelID { get; set; }


 }

I want the web part properties to show the available Ranking Models so the user can select them from a dropdown list. For this to work, we cannot use regular properties and have to implement an EditorPart. The reason for this, is that regular properties don’t allow you to dynamically load values through code behind and I don’t want to hardcode the values for the dropdown list.

Next, create the EditorPart:

The EditorPart needs to get the names and values of the available ranking models. For this to work, we need to connect to our Search Service Application and fetch the available models:

class EnhancedCoreResultsEditorPart:EditorPart
    {
        private DropDownList rankingModelList = new DropDownList(); 

        protected override void CreateChildControls()
        {
            base.CreateChildControls();

            RankingModelCollection rankingModels = null;

            SPServiceContext context = SPServiceContext.GetContext(SPContext.Current.Site);
            SearchServiceApplicationProxy searchApplicationProxy = context.GetDefaultProxy(typeof(SearchServiceApplicationProxy)) as SearchServiceApplicationProxy;
            SearchServiceApplicationInfo searchApplictionInfo = searchApplicationProxy.GetSearchServiceApplicationInfo();
            Guid searchApplicationID = searchApplictionInfo.SearchServiceApplicationId;
            SearchServiceApplication searchApplication = SearchService.Service.SearchApplications.GetValue<SearchServiceApplication>(searchApplicationID);

            Ranking ranking = new Ranking(searchApplication);
            rankingModels = ranking.RankingModels;

            foreach (RankingModel rankingModel in rankingModels)
            {
                ListItem item = new ListItem();
                item.Text = rankingModel.Name;
                item.Value = rankingModel.ID.ToString();
                rankingModelList.Items.Add(item);
            }

            this.Controls.Add(new LiteralControl("<div class=\"UserSectionHead\">Ranking Model</div>"));
            this.Controls.Add(new LiteralControl("<div class=\"UserSectionBody\">"));
            this.Controls.Add(rankingModelList);
            this.Controls.Add(new LiteralControl("<br/><br/></div>"));

            this.ChildControlsCreated = true;
        }
}

The EditorPart sets the web part RankingModelID using the value from our dropdown list.

     public override bool ApplyChanges()
        {
            EnsureChildControls();

            EnhancedCoreResults enhancedCoreResultsWebPart = (EnhancedCoreResults)this.WebPartToEdit;
            if (enhancedCoreResultsWebPart != null)
            {
                enhancedCoreResultsWebPart.rankingModelID = rankingModelList.SelectedValue; 
            }
            else
            {
                return false;
            }
            return true;
        }

        public override void SyncChanges()
        {
            EnsureChildControls();

            EnhancedCoreResults enhancedCoreResultsWebPart = (EnhancedCoreResults)this.WebPartToEdit;
            if (enhancedCoreResultsWebPart != null)
            {
                rankingModelList.SelectedValue = enhancedCoreResultsWebPart.rankingModelID;
            }
        }

Wire up the EditorPart in our custom Core Results class:

        EditorPartCollection IWebEditable.CreateEditorParts()
        {
            List<EditorPart> editors = new List<EditorPart>();
            EnhancedCoreResultsEditorPart editorPart = new EnhancedCoreResultsEditorPart();
            editorPart.ID = "EnhancedCoreResults_editorPart";
            editors.Add(editorPart);
            return new EditorPartCollection(editors);
        }

        object IWebEditable.WebBrowsableObject
        {
            get { return this; }
        }

Create the logic that actually sets the RankingModelID by overriding the ConfigureDataSourceProperties() method:

     protected override void ConfigureDataSourceProperties()
        {
            if (this.ShowSearchResults)
            {
                base.ConfigureDataSourceProperties();

                if (!string.IsNullOrEmpty(rankingModelID))
                {
                    CoreResultsDatasource dataSource = this.DataSource as CoreResultsDatasource;
                    dataSource.RankingModelID = rankingModelID;
                }
            }

        }

Note: I found several articles on the web showing similar functionality by overriding the GetXPathNavigator() method and setting the ranking model through the SharedQueryManager instance. Somehow I couldn’t get this to work the way I wanted to so I decided to do it differently.

That’s it, build, package and deploy.

You can download the Visual Studio solution here.

To fix this, you need to edit the ItemStyle.xsl (preferably a custom one, see this post). You would just have to add the following command to the part outputting the HTML:

<xsl:value-of disable-output-escaping="yes" select="$blah"/>

One other thing to watch out for, is when creating summary descriptions from these rich text fields. Say you have this text:

<h1 class="ms-rteElement-H1">Cras porta pharetra magna eget consectetur. </h1> <p class="ms-rteElement-H1"> </p> <p>Etiam eget nibh eu libero dictum congue. Etiam tempor auctor lectus, at porta dolor molestie vitae.</p>

And you want to create a summary of 150 characters with a “Read More” link. You would cut off the output rendering and potentially leave open HTML tags! And that could really screw up the user experience. So another option would be to strip all html from your output. This way you will loose the rich text markup (H1, bolds and so on), but ensure valid html output.

To accomplish this, you would also need to edit the ItemStyle.xsl (again preferably a custom one) and include some kind of HTML stripping function.

<xsl:template name="Functions.RemoveHtml">
    <xsl:param name="String"/>
    <xsl:choose>
      <xsl:when test="contains($String, '&lt;')">
        <xsl:value-of select="substring-before($String, '&lt;')"/>
        <xsl:call-template name="Functions.RemoveHtml">
          <xsl:with-param name="String"
            select="substring-after($String, '&gt;')"/>
        </xsl:call-template>
      </xsl:when>
      <xsl:otherwise>
        <xsl:value-of select="$String"/>
      </xsl:otherwise>
    </xsl:choose>
</xsl:template>

 Get-SPEnterpriseSearchRankingModel -SearchApplication "Search
 Service Application"

The default Core Results Web Part uses the MainResultsDefaultRankingModel and the People Results Web Part uses the MainPeopleModel. To try the different models, you can just append the search results querystring with &rm=<guid>

So …/Pages/peopleresults.aspx?k=john&s=People&rm=0bba4d7d-4f2c-4086-975a-8f9d2b6c6d53 would return people results using the NameModel.

If you want to permanently alter the used ranking model, you have to adjust the Results Web Part. Follow these steps to modify the normal search:

1. Export the Core Results Web Part.
2. Add or modify the following property, for instance:
   <property name="DefaultRankingModelID" type="string">0bba4d7d-4f2c-4086-975a-8f9d2b6c6d53</property>.
3. Import and re-add the web part.

For people search, this unfortunately does not work very well. The People Core Results Web Part will reset your DefaultRankingModelID back to use the MainPeopleModel once you upload your web part. Just add a (hidden) Core Results Web Part to your page and configure the property that way.