SharePoint Config

Before getting into SharePoint 2010 I’d like to recap on some of the things I’ve learnt using SharePoint 2007. Much has progressed since I started working on SharePoint 2007 Technology Adoption Program (TAP) projects using the SharePoint 2007 Beta versions in early 2006. As a developer some of the biggest improvements I’ve noticed are the availability of tools and information.

In 2006 we were creating WSP files by manually maintaining DDF files and using makecab, a process that is now fully automatable (and integrated into Visual Studio) using freely available tools such as the brilliant WSPBuilder utility. I also remember spending two whole days trying to create a list definition as the documentation on MSDN wasn’t (and still isn’t) complete. Not surprisingly the ‘Creating a Custom SharePoint 2007 List Definition’ blog post I wrote afterwards still draws in over 1500 page views a month.

So below are a list of some of the ways I like to do things when creating custom SharePoint 2007 solutions (with a focus on Web Content Management).

Development environment setup

I’m a big fan of Microsoft Hyper-V for development (and even QA/UAT environments). Performance is great and you have the benefits of using checkpoints – a feature I’d now find it hard to live without. I’ve used virtual machines on secondary hard drives before but performance was never amazing. Installing Windows Server on your developer machines is another option but if something goes wrong it can take a while to rebuild.

I also like to create a base image with all the development tools I frequently use. This can then be copied for new developers/projects, renamed/joined to a domain and ready for the (scripted) SharePoint install. Some of the tools I like to include are:

· WSPBuilder – brilliant for packaging WSP and quick deploy of files to the 12 hive/SharePoint root or GAC.

· .Net Reflector – frequently used to work out what is going on inside all those SharePoint assemblies.

· SharePoint Manager – great for exploring your SharePoint farm in detail and finding out what content types are in use or identifying the GUID’s for different objects.

· SharePoint designer (aka SharePoint destroyer) – good for prototyping, especially things like the Data View Web Part and Page Layouts before taking these elements into source control so they can be managed and deployed with the rest of the solution.

· U2U Caml Builder – A handy tool for creating CAML queries.

· zevenseas Search Coder – great for getting search queries right before creating controls that use SharePoint search.

· Firefox and Firebug – My HTML/CSS inspection tool of choice.

· SPDisposeCheck – Tool for checking you are properly disposing of SPSite and SPWeb objects. Read the article Best Practices: Using Disposable Windows SharePoint Services Objects if you haven’t already.

· DebugView – An easy way to inspect standard call to System.Diagnostics.Trace or Debug.

· Fiddler 2 – Good for inspecting network traffic for hunting down network related issues.

For source control I like TFS as it also links in work item tracking/reports/bug tracking functionality but if people are working remotely Subversion is pretty quick across the web.

Other handy tips are to add the SharePoint XML schema files into Visual Studio to give you intellisense, and to disable the Certificate Revocation List check to reduce app pool recycle/Stsadm load times – especially when the development environment doesn’t have internet access. You can also set development SQL databases to simple recovery to reduce disk space (although ideally with a checkpoint to roll back to).

Scripted SharePoint installation

If you are going to be installing SharePoint on more than one environment I’d highly recommend scripting the base installation. The benefits are huge, not only does it drastically reduce the time to build a new server (e.g. multi-server farms can be built from the OS up in 2-3 hours), it ensures that all your environments are in sync and lowers the risk of configuration related issues cropping up late in the deployment cycle. A simple batch script or even better a Powershell script will do most of the work here – simply call psconfig and Stsadm commands for the bulk of the work. To fully automate the process Gary Lapointe’s Stsadm commands for 2007 and his brilliant Powershell scripts for SharePoint 2010 are a great start and it is fairly straightforward to create your own if you have any additional requirements.

Project setup

If you are using WSPBuilder check out the article “SharePoint Developer Productivity Tip #1 – Visual Studio Project Templates” which walks through common setup tasks and provides a Visual Studio template for starting SharePoint projects. I’ve extended this idea and created SharePoint Intranet and Public Website base projects I use to get up and running quickly with new SharePoint projects. These contain the following elements that I can tweak and extend for each solution (all packaged up as features/solution artifacts):

· Site Definition – A base site definition containing relevant features (e.g. publishing infrastructure). I like having a site definition for each site as it means you don’t have to staple features to existing site definitions, and you have more control over the features, lists, properties and default pages for each site.

· Master pages page layouts – A common requirement for almost every project. For intranet projects this looks fairly similar to the OOTB default masterpage but allows for more control over the layout of the page and adding custom controls etc. For public facing sites or other sites that require significant UI changes (e.g. div based layouts) I’ll start from a minimal master page especially if the HTML will be pre-built or a complete change from the OOTB master pages. When creating new page layouts I’ll either create these using SharePoint designer and copy them into Visual Studio or even just create them from scratch in Visual Studio so they are easily deployable. SharePoint designer has its place but I’ve found it doesn’t work well for team based development as it is hard to manage changes and quickly deploy these to other developers or package into a release.

· Site columns, content types and list definitions – custom metadata is required for almost every project so I like to have content types that extend the OOTB content types such as the Welcome Page and/or Article Page so I can easily add custom columns as required. All packaged as a feature for easy deployment.

· User controls – great for adding functionality that you want to bake into a master page or page layout. Common examples are custom navigation elements (e.g. a footer control) or any component where you don’t need the flexibility of a web part but want a design surface.

· Web parts – if you want to be able to allow end users to place a component on a page and/or modify settings then web parts are the way to go. Common requirements here are aggregation web parts such as rollups or related items. I don’t like hard coding HTML/Javascript inside my assemblies so I’ll usually either load an XSL transform or ASCX file which contains the HTML. This makes it far easier to make changes to the output and speeds up development. Additionally in many cases the OOTB web parts suffice (especially the CQWP and/or Summary Links) so I’ll set the properties I want, export them and package them up as a web part specific to the project I’m working on (often with a custom XSLT if the web part supports it). Waldek has some more information on this in his article “Leveraging ASP.NET User Controls in SharePoint development“.

· Server controls – server controls are great for functionality that doesn’t require a design surface. Common scenarios here are things like display panels (e.g. showing different content based on a zone) or things like field controls that aren’t provided by OOTB like the email address of the page owner.

This is only really a start, and big projects will have many other components such as event handlers, field controls and many others that aren’t in the scope of this article. Wherever possible, however, I’ll package everything up using SharePoint features so I can deploy this as one or more WSP’s.

Scripted solution deployment

Deployment is often underestimated by inexperienced SharePoint developers, but can easily cause lost days manually deploying and configuring to try and get a release out. Additionally manual deployment steps increase the risk of inconsistencies between environments which isn’t good for platform hygiene and can lead to expensive delays tracking down deployment related issues. Having scripts to quickly deploy your solution will make it easy to get new developers started, apply changes, saving hours or days in the development cycle.

For SharePoint 2007 I’ve found batch scripts that call Stsadm commands together with Gary Lapointe’s Stsadm extensions do most of the work. You can either extend these or even use the feature framework do automate tasks such as creating content – I often use a feature receiver that reads in an XML file to create pages/web parts/lists etc using the object model. While this can be done using CAML in several cases I’ve found it much faster to create a cut down provisioning feature especially to deploy web parts and make updates to lists etc.

Summary

This isn’t a comprehensive summary of everything you need to consider for a SharePoint project but I hope it provides some helpful tips if you continue to use SharePoint 2007 as a development platform. Comments are especially welcome on this post, I’d love to hear how other people work. Additionally if you would like to hear more on anything please drop me a line or leave a comment below.

Additional resources

Chris O’Brien has some other good tips in his articles “My top 5 WCM tips presentation” and “My favorite SharePoint 2007 development techniques (with an eye on SP2010)”

Waldek Mastykarz has a page containing a bunch of useful SharePoint tools and his blog is well worth a read for other useful SharePoint development techniques

And don’t forget the official documentation on Technet and places such as the SharePoint developer site which has slowly become more and more useful.

I’ve recently been confirmed as a speaker at the SharePoint 2010 Evolution Conference in London. The conference has plenty of talented speakers, lots of great sessions, and promises to be the premier SharePoint event outside the US. From the www.sharepointevolutionconference.com website:

What is it?

This 3 day SharePoint 2010 Evolution Conference, consists of over 70 Sessions dedicated to IT Pro’s/Developers/Designers/Information Workers/Business Adoption and Power Users and with a new Deep Dive 400 track and 5th Power User Track added this is set to be Europe’s Premier SharePoint Conference for 2010!

Why you should attend

If you attend one SharePoint conference for SharePoint 2010 in Europe here are just a few reasons why you should attend the SharePoint Evolution Conference in London on April 19th to 21st 2010

• The conference is dedicated to SharePoint
• Born from the very successful Best Practices conference in 2009 hailed by many as the best SharePoint conference ever.
• Sessions list second to none, speaker list second to none.
• 55 Expert SharePoint speakers from Microsoft and well known companies. Never before has such a group of talented speakers like this been brought together.
• Click here for another 12 more reasons…

The session I’ll be presenting is part of the ‘Community Track’ and will be on ‘Creating a tag driven information architecture using SharePoint 2007′.  This session will cover ways in which to utilise the tagging features of MOSS to create an attractive and easy-to-use intranet portal. We will use the New Zealand Ministry of Transport corporate intranet as an example. This intranet has won several awards including Microsoft’s Partner Solution of the year award, and was named in Neilson Norman Group’s “Top Ten Intranets of 2008”. A key part of this project was defining the information architecture (IA) for the site, and then designing the site structure around the IA to ensure optimal usability. The second key part of the project was to include community features that would engage intranet users and keep them coming back to the site. This session will cover how the IA and community tools were designed and delivered using MOSS 2007.

With a bit of luck we’ll also look at how to apply the same concepts in SharePoint 2010 using the new taxonomy and metadata management features.

Hope to see you there!

Performance testing can be useful exercise for many SharePoint deployments. It allows you to validate your infrastructure decisions, identify and iron out any bottlenecks, and prove that the environment can effectively handle the expected user load. It can also be useful to measure the effect of changes to the environment, and allows you to configure the environment for optimal performance.

To assist SharePoint performance testing projects I have created the SharePoint Performance Testing project on CodePlex. The project consists of a series of load tests and some guidance documentation that can be used to quickly get a performance test underway. I have created these tests using Visual Studio 2008 Team Test Edition (VSTT) as it provides an easy way of managing and running the tests against a farm environment. As a start I have created tests that include common SharePoint user actions such as browsing, searching, uploading and downloading files.

The goal of the project is to make it as easy as possible to get up and running so all you need to get started is a URL of a SharePoint site and an account. It is then easy to extend the core tests with information about your site so that the tests reflect actual usage (e.g. pages to use for the browse test, documents to use for uploading etc) as this information is all stored within a set of configuration files, rather than within the test themselves.

Figure 1. Adding entries to the Pages.csv file will result in these URLs being used in the ‘browsing’ load tests.

Once you are happy with the configuration you can then create a load test or use one of the example ones included to simulate a variety of actions on your site. For example the ‘Collaboration’ load test uses a mix of browsing, searching, uploading and downloading. Settings such as the number of users to simulate, and the servers to monitor can be selected. Once this is in place Visual Studio can run the tests and collect a rich set of statistics as shown below.

Figure 2. A small subset of the statistics recorded for a load test showing CPU and Memory utilisation on all servers in a SharePoint testing farm.

There are a lot of things to consider in a performance testing project so I’ll be following this up with a series of posts on this, but in the meantime if you would like to try the performance tests please do. Any feedback or feature requests are welcome. You will need either Visual Studio 2008 Test Edition or the Team Suite Edition (or Visual Studio 2010 Ultimate).

A more detailed description of how to use the tool is included in the documentation on Codeplex.

This post describes how to use the ContentTypeBinding element to avoid an error that can occur creating publishing pages in the following scenario:

• Custom content types and associated page layouts are installed on a Publishing Site.
• A user with ‘contribute’ rights creates a page based on a content type that does not exist in the pages library for the current site.

What happens in this situation is that the publishing features try to automatically copy the content type from the root site into the pages library. If the user only has ‘contribute’ permissions (e.g. is in the default Site Members group) this fails with the following error message:

Object reference not set to an instance of an object.   at Microsoft.SharePoint.Publishing.PublishingPage.SetContentType… (full details below)

When searching for this error I found a couple of posts that suggested solutions using C# code but an easy way to fix this is to bind the custom content types to the pages library so that they already exist when users try to create new pages, thus avoiding the error. This can be accomplished through the use of the ContentTypeBinding  element in a web scoped feature. This also allows the content type to show up on the ‘new’ menu. An example feature to do this is shown below:

Feature Xml:

<?xml version=”1.0″ encoding=”utf-8″?>
<Feature  Id=”bb3b9420-e97f-11de-8a39-0800200c9a66″
          Title=”Custom content type bindings”
          Description=”Binds custom page content types to the pages library”
          Version=”12.0.0.0″
          Hidden=”FALSE”
          Scope=”Web”
          DefaultResourceFile=”core”
          xmlns=”http://schemas.microsoft.com/sharepoint/”>
  <ElementManifests>
    <ElementManifest Location=”elements.xml”/>   
  </ElementManifests>
</Feature>

Elements Xml:

<?xml version=”1.0″ encoding=”utf-8″ ?>
<Elements xmlns=”http://schemas.microsoft.com/sharepoint/”>

  <!—Custom Article Page –>
  <ContentTypeBinding ContentTypeId=”0×010100C568DB52D9D0A14D9B2FDCC966…” ListUrl=”Pages” />

</Elements>

The key things to note here is the ContentTypeBinding element that has a ContentTypeId and ListUrl attributes. So adding in bindings for all your custom page content types provides a clean way of preventing the error and getting your content types to appear on the new menu of the pages library. This approach can also be used to bind content types to lists that have been defined outside of the current feature scope (to bind a content type to a custom list definition you are creating use the ContentTypeRef element as described in the post Creating a Custom SharePoint List Definition)

The other thing to note is that the feature is scoped to Web (as I haven’t got this to work at other levels but your mileage may vary).

The screenshots below show how this change is reflected in the UI.

Before:

After (note additional content type available):

The full error message is:

Object reference not set to an instance of an object.   at Microsoft.SharePoint.Publishing.PublishingPage.SetContentType(SPContentType listContentType)
   at Microsoft.SharePoint.Publishing.PublishingPageCollection.<>c__DisplayClass5.<Add>b__0()
   at Microsoft.Office.Server.Diagnostics.FirstChanceHandler.ExceptionFilter(Boolean fRethrowException, TryBlock tryBlock, FilterBlock filter, CatchBlock catchBlock, FinallyBlock finallyBlock)
   at Microsoft.Office.Server.Diagnostics.ULS.SendWatsonOnExceptionTag(ULSTagID tagID, ULSCat categoryID, String output, Boolean fRethrowException, TryBlock tryBlock, CatchBlock catchBlock, FinallyBlock finallyBlock)
   at Microsoft.SharePoint.Publishing.PublishingPageCollection.Add(String name, PageLayout layout)
   at Microsoft.SharePoint.Publishing.Internal.CodeBehind.CreatePagePage.NewPageItemSave(String pageName, PageLayout pageLayout)
   at Microsoft.SharePoint.Publishing.Internal.CodeBehind.CreatePagePage.CreateStandardPage(String pageName)
   at Microsoft.SharePoint.Publishing.Internal.CodeBehind.CreatePagePage.ButtonCreatePage_Click(Object sender, EventArgs e)
   at System.Web.UI.WebControls.Button.OnClick(EventArgs e)
   at System.Web.UI.WebControls.Button.RaisePostBackEvent(String eventArgument)
   at System.Web.UI.Page.RaisePostBackEvent(IPostBackEventHandler sourceControl, String eventArgument)
   at System.Web.UI.Page.ProcessRequestMain(Boolean includeStagesBeforeAsyncPoint, Boolean includeStagesAfterAsyncPoint)

References:

Publishing Page creation bug on Robin Meure’s blog

PublishingPage create error on Bernd’s blog

ContentTypeBinding Element on MSDN

Blogging has taken a back seat over the past year, partly as much of my time has been spent travelling through Australia, Japan and an amazing three months in South America. I’ve finally settled into busy London, however, and will again be working with and blogging about SharePoint and web development.

So as part of my move to the UK I will be directing my old blog which is currently at ari.provoke.co.nz over to this shiny new WordPress one, and will add new content on SharePoint 2007 and (hopefully soon) SharePoint 2010.

The “Open with Windows Explorer” action available for document libraries in SharePoint relies on a WebDav client service (i.e. WebClient) which isn’t installed by default on Windows Server 2008. To get this working you need to install the “Desktop Experience” feature. This can be done by navigating to Server Manager > Features > Add Feature > Desktop Experience (requires reboot).

This will also allow you to save Office documents directly into a SharePoint site if you are using Windows Server 2008 as a client.

References:

• Using the WebDAV Redirector
• Browsing SharePoint using WebDav from Windows 2008

For some reason certain¹ SharePoint lists don’t have the handy “Edit in datasheet” option available to allow bulk editing of items. One of these lists is the MOSS Picture Library which means that although images can be uploaded in bulk, users have no easy way of bulk tagging these items (e.g. adding ‘christmas party’ as a keyword to 20 photos at once).

I would have thought this was a fairly common scenario but couldn’t find a lot of info out there so here are some non-code alternatives to consider:

Create an Access View

As with the “Edit in Datasheet” functionality this requires the users to have MS Access installed locally, but unlike the “Edit in Datasheet” view this takes the user away from SharePoint and opens the Access client which is fairly clunky². Having said that if only a few ‘power users’ are performing bulk updates this might be a viable way of providing bulk updating capabilities.

Colligo Contributor

This does require a per-user licence but has a bunch of great features including the ability to bulk upload and bulk tag items at the same time. If ease-of-use is a priority I’d definitely check this out. Colligo also offers wicked offline sync and email integration.

As shown below, after uploading multiple images through a standard windows explorer window users can tag the items all at once using the Colligo client (custom list fields included).

Depending on the requirements another easy alternative is to simply use a document library instead of a Picture Library. Obviously there is a loss of functionality including slideshow and image preview but this may be an option in some cases.  If there are other options I’ve missed please drop a note in the comment section below.

^{1. The lists that don’t have the “Edit in Datasheet” option are: Calendar, Discussion Board, KPI List, Picture Library and Survey}

^{2. Clunky: I got a security warning then a loading window for several seconds before opening the view in Access. It also made me re-create the entire view when I changed the list schema (i.e. added an extra column).}

I’ve been involved in several public website projects that have involved using MOSS content deployment. While content deployment is easy to set up for simple scenarios, there are a number of things that can trip you up if you have a significantly customised environment. In this post I’ll give details and solutions to on some of the common problems, and general tips on how to make this process run as smoothly as possible.

This post doesn’t contain a step by step guide for setting up content deployment, for that see the article “Content Deployment Step by Step Tutorial” on Jackie Bodine’s blog, or for a introduction see the articles “Plan content deployment” on TechNet or “Content Deployment” on the SharePoint team blog.

Pre-deployment tasks

It is important to understand the process before attempting to run the content deployment process. In particular you should ensure that:

• The destination SharePoint site is created using the blank site template (not a publishing site). All content and features (including the publishing features) will be copied and activated as per the source site so you need to deploy to a completely blank site collection.
• Any custom features/solutions need to be installed on the destination server. Solution packages are not copied as part of the content deployment, so ensure these are available on the destination server and deployed to the relevant web application before starting content deployment.
• Ensure all items are published. Unpublished items are not visible to anonymous users and if dependant resources are not available this can mean pages do not display. An easy way to ensure that you publish everything is to use the ‘All draft documents’ report. Select Site Actions > View Reports > All draft documents to see a list of items not yet published.

Deployment

• Test the full deployment in a test environment – If you have made significant customisations to the publishing site there is a high chance that problems will arise the first time you run a content deployment job. Don’t leave this til the production deployment, set this up when you do your first release to the test environment so you can iron out bugs early. If you don’t have two separate servers in your test environment at least create two separate web applications and deploy between them, this still provides a good test of the export/import process.
• Enable detailed logging to identify what caused failed exports/imports – As any developer will attest, identifying where an error occurs is crucial to solving the problem. Using the following code to run as export will give you details on the item that caused deployment to fail (originally from Stefan Gobner’s excellent article) .

SPExportSettings settings = new SPExportSettings();
settings.SiteUrl = “http://source“;
settings.ExportMethod = SPExportMethodType.ExportAll;
settings.FileLocation = @”c:\export”;
settings.FileCompression = false;
settings.CommandLineVerbose = true;

SPExport export = new SPExport(settings);
export.Run();

The key here is the CommandLineVerbose property of the SPExportSettings object. When running this from the command line you will see detailed output containing each item as it is processed for export, allowing you to identify the item that the export failed on.

The screenshot below shows an example of what this looks like running as a console app if an error occurs.

A similar process can be used for import with the following code.

SPImportSettings importSettings = new SPImportSettings();
importSettings.SiteUrl = “http://destination“;
importSettings.FileLocation = @”c:\export”;
importSettings.FileCompression = false;
importSettings.RetainObjectIdentity = true;
importSettings.CommandLineVerbose = true;
SPImport import = new SPImport(importSettings);
import.Run();

Post deployment

Almost there! But there are a few things that still might catch you out

• Master pages settings are not deployed correctly – If you have changed the master page for the site this might not get set in the destination site. This may cause errors with the default page for the site if your page layouts contain additional content placeholders. According to Andrew Connell there is now a hotfix that resolves this issue but at the time of writing this is not publicly available. To fix the problem without the hotfix, navigate to http:///_layouts/settings.aspx and select ‘Master Page’ to change the master page to the one you are using.
• Turn on error messages for the destination site – If you are still getting errors and haven’t turned on detailed error message set the stacktrace attribute of the SharePoint/SafeMode element to “true” and the mode attribute of the system.web/customErrors to “off” in the web .config.

I’ve come across a number of different errors with content deployment so I recommend testing this as early as possible. Most of the problems are easily fixed but some may require rework, so identifying these early helps reduce the impact on development effort (and reduce stress at deployment time). And while the content deployment process isn’t as stable as one might like, since it has been around for a while most of the bugs have either been fixed or are documented and provide workarounds.

I’m pleased to say that the article I wrote a few months ago on ‘how we did it: tag driven IA for MOSS’ was noticed and has been re-published on the SharePoint team blog.

Read the updated article – How We Did It – Tag Driven Information Architecture using MOSS 2007 for the New Zealand Ministry of Transport

Early last year I was involved in developing a Microsoft Office SharePoint Server (MOSS) based Intranet for the Ministry of Transport. This post explains how we utilised the tagging capabilities provided by MOSS to create this award winning Intranet.

Findability was a major focus for the Intranet. All content entered into the site is tagged with metadata that we can use to display content in a variety of ways. This also allows us to display; tag clouds, contextual navigation, links to related content, enhanced search results, and provide summary views of relevant content from various areas of the site.

Some examples of how this works are:

The homepage for the “Tools and Resources” section of the site that contains a tag-cloud of all the company-wide documents and articles:

Selecting the “Administration” topic shows all content tagged with the “Administration” value for the “Topic” attribute. Users can then sort and filter the results to further refine the results. Note that the navigation is also driven by the tags that relate to content within the site.

A typical page on the site will contain a list of tags, clicking on these will take the user to search results page, showing similarly tagged items.

The search results for the “Manual” content type. Note the search results have been customised to show related tags to help further identify content.

The homepage for the intranet, showing summary views of content from various sections of the website:

To build these features we used a combination of custom ASP.NET development and UI customisations using SharePoint designer. The following steps detail the process we used to define and implement the Information Architecture and create these features.

Step 1. Defining the Information Architecture

The first step in the process is defining the content types and attributes that you will use for the site. This step needs to be done by someone who understands the business and the ways in which people work as the information architecture will define how content is categorised and accessed. At Provoke, Information Architects within our Design and User Experience (DUX) team are responsible for this step, and produce an Information Architecture specification that contains a list of the metadata elements that will be used, along with a content type-metadata mapping that defines which attributes will be captured for each content type. A sample of this document is shown below.

One row from the metadata set:

Attributes by content type:

Step 2. Creating the Information Architecture

The next step in the process is to create the metadata attributes and content types within MOSS. To do this we created a series of lists that contained the options for each attribute such as Topic or Origin, and then created site columns that referenced these lists. We then created the content types and used the content type-attribute mapping to add the required site columns (attributes) to each content type. The last step in the process was to add these content types to the relevant document libraries. Now when users add content to a document library they are shown the relevant tags based on the type of content they have uploaded.

Document based tagging:

We also created a series of page layouts (one for each content type) so that if users created a page within the site they would be able to tag the content when editing the page:

Step 3. Customising the User Interface

We now have the basic architecture that we need for users to create and tag content appropriately. To make it as easy as possible for users to find what they are after we provided several customisations of the Publishing site template. These were:

• Aggregating the most popular and recent content on the homepage for each site
• Using tag clouds to provide access ways into the site
• Providing contextual based navigation that displayed tag clouds for a given site
• Displaying related tags on each page, and displaying related articles when users clicked on these tags

Aggregating the most popular and recent content on the homepage for each site

Each site’s homepage contains listings of relevant content drawn from within the current section and/or subsections of the Intranet. To do this we made heavy use of the Data View Web Part. Using SharePoint designer we simply added several Data View Web Parts to each page, and selected the relevant list or library that contained the content. As the Data View Web Part contains a XSL template, our designers were easily able to customise this to provide a rich user interface as shown below:

The homepage for the Intranet, drawing content from several sections of the website:

Tag clouds

As an alternative to displaying the most recent or popular content, for sections of the site that had large amounts of content we used the homepage to display tag clouds to provide access ways into the site. To accomplish this we created a component that would calculate the tag counts every time content was updated, and a page layout that contained several Data View Web Parts to display these tags.

Tag based navigation

The metadata lists used for the tag clouds are also used to drive the navigation for sections of the site. Selecting an item in the menu takes the user to a filtered view of the content in the site that the user can then sort or filter further to help find the content they are looking for. This dynamic view of the content means users are not forced to go down a single path to find content, as is the case with tree based navigation structures. Users have the ability to filter by the attributes they feel will return the content they are after. This also has an advantage over search, as users easily sort and filter results with more control.

Related tags

Each content page on the site contains a related tags section that looks at the metadata attributes for the page, and displays each item as a link to search results for a similar item. To achieve this we built a custom ASP.NET user control that we put on each page layout.

Summary

The MOSS platform provides a great platform for implementing an information architecture that makes it easy for users to find what they are looking for.