Sjoert Ebben - Sharepoint blog

SharePoint 2010 social data, part 1

2011-11-13T23:09:00.001+01:00

Background
One of my customers wants to implement social features in their SharePoint intranet. As their current version is SharePoint 2007 and the implementation of social add-ons didn’t really succeed, a decision was made to migrate to SharePoint 2010. A presentation at Microsoft made the customer very enthusiastic, but within a week they realised that the OOTB features weren’t what they were looking for. In short: the customer wanted something like the Facebook wall.

There’s limited information on how to achieve this in SharePoint. In a nice blog post from Bjørn Furuknap (http://blog.furuknap.net/why-sharepoint-2010-social-features-suck), I quickly learned that it would be a “challenge” so I took a deeper dive into the social functionality of SharePoint 2010. While doing this, I wanted a more or less complete overview so why not blog about it?

This article is the first in a series of articles on this topic . We’'ll start with the basics at level 100: an overview of social data in SharePoint 2010. If you’re a code cruncher, you might want to skip this post, although you might find it useful to get the overview.

What is social data in SharePoint 2010?
What is social data anyway? Asking that question to Google returns a lot of pages telling us what we can do with social data, not what it actually is. On http://socialdatastrategies.com/2011/what-is-social-data/, you can find a definition. If you redefine the search to “social media”, you’ll find more, including an interesting paper by iCrossing: http://www.icrossing.co.uk/fileadmin/uploads/eBooks/What_is_Social_Media_iCrossing_ebook.pdf, The paper is a few years old, but I thinks it’s still a good read.

Unfortunately, it doesn’t tell us much about social data in SharePoint so I’ll take the liberty of defining something myself.

Social data in SharePoint is largely information added to authored information already in SharePoint: pages, list items, documents, user profiles. Social data is largely non-authoritative and it’s purpose is to add value by users who do not necessarily have authoring rights. Social data adds a layer of (corporate) crowd knowledge and intelligence on top of managed information. However, social data is also information about a user profile (like LinkedIn) and unmanaged shared knowledge.

SharePoint offers the following types of social data:

tagging
rating
commenting
blogging
profile events or updates
contributions to discussions and wiki’s

Social data is visible on various locations:

On a page in a note board or tag cloud
On an item (document, list item, page)
In a newsfeed on the user’s profile page (showing activities of the user)
In the My Newsfeed page in the my site host (showing activities the user is subscribed to)
As a blog post
As a contribution to a wiki
As an entry in discussion forums (based on the discussion list template)

The most prominent place social data is visible, is the “activity stream”, also known as the newsfeed on the my site host:

Social data with tagging is also a way of discovering how people within your organisation look at content: a formal taxonomy enforces a corporate content classification, a “folksonomy” (using tags users can use freely) exposes how people really classify content.

Important: rating, tagging and notes are SharePoint 2010 Server features! A User Profile service application is required to enable them.

Note: For this article, I’ll focus on social data that appears in the newsfeed. This does not include discussion forums and wiki’s.

Creating social data
Social data is created on various locations:

Tagging an item
A user can tag an item with a keyword. The item can be a page, a document or any list item. Tags are actually keywords; these keywords are stored in the Taxonomy Term Store in a managed metadata service application.

Tagging can be done at various locations in SharePoint. When you open an OOTB site, for example, you’ll notice the two large buttons:

The “I Like It” button is just a shortcut for adding a tag with that name. If you click on the Tags&Notes button, you’ll get a dialog with options to add tags and notes:

A tag can be made private by checking the “Private” checkbox:

The result of the tagging is displayed in the newsfeed:

Tags can also be shown in a tag cloud web part:

This web part can be configured to show tags for the current user, for all users or all users for the current URL.

A nice additional feature is the tag community page. This is a generic page in the My Site host (tagprofile.aspx) that takes a tag (=term) ID as parameter and shows information about and actions related to the tag:

You can’t really do collaboration stuff here but leaving a note. Unlike Twitter, to leave a note for this tag, you have to go to the tag page itself instead of hash tagging your note. I bet this is going to be improved in vNext.

Tagging like this does not show up in search results either. You can add a Managed Metadata field to a content type or list and use the same term set as the tagging feature to add keywords to an item that will show up in search. However, these will not show up in the newsfeed.

Useful links:

Social tagging overview (http://technet.microsoft.com/en-us/library/ff608137.aspx)
Video: Use tags and notes to share information with colleagues (http://office.microsoft.com/en-us/sharepoint-server-help/video-use-tags-and-notes-to-share-information-with-colleagues-VA102465712.aspx)

Leaving a note
In the Tags&Notes dialog, you can also add a note in the “Note Board”. Existing notes are displayed under the entry box:

The Note Board can be added as a web part to a page as well:

Note: The Note Board is not dynamic like your favorite Twitter client and will only show new notes from other users after a page refresh. You can’t respond to a note as you’d do in a discussion list: all notes are in a flat view.

To add a tag or note on a list item, you need to check the checkbox in the list view, which enables the “I Like It” and “Tags & Notes” buttons. Clicking these buttons opens the Tags_Notes dialog.

Notes are just plain text, so no (hash) tagging is possible. Notes are not indexed either so you can’t search for them. Building a search solution to search for notes containing a particular hash tag won’t work.

Useful links:

Video: Use tags and notes to share information with colleagues (http://office.microsoft.com/en-us/sharepoint-server-help/video-use-tags-and-notes-to-share-information-with-colleagues-VA102465712.aspx)

Rating an item
Users can show their appreciation of content by rating it. Rating can be done on any list item (which includes pages and documents) but only when the rating feature is enabled.

Important: the rating feature cannot be activated from the UI. You’ll need PowerShell to activate it.
Rating is not enabled by default in a list or library so you’ll need to enable it via the list/library settings:

Enabling rating adds two columns:

Rating (0-5): the average rating value. This is displayed in a special field with stars. Under water, it’s a number value.
Number of Ratings: does exactly what it says

You can also add the rating site column to a content type to enable rating on just a selection of types.
Once available, a user can rate the item:

Mouseover the stars and click one of them.

Important: when a user rates an item, this action is not picked up immediately for other users. There is a timer job, scheduled hourly by default, that will calculate the average rating. You’ll notice a difference in the color of the stars: with blue stars an average has been calculated, with yellow stars this has not yet been done. When a user refreshes a page after rating an item on the page, this rating will not be visible before the timer job has run!

Useful links:

Enable users to rate content (http://office.microsoft.com/en-us/sharepoint-server-help/enable-users-to-rate-content-HA101791797.aspx?CTT=3)
Turn on Ratings Feature in SharePoint 2010 (http://kroondyk.blogspot.com/2010/06/turn-on-ratings-feature-in-sharepoint.html)
Managing privacy (http://technet.microsoft.com/en-us/library/ee620541.aspx)
Using the New SharePoint 2010 Ratings Feature in Search (http://blogs.technet.com/b/speschka/archive/2009/10/28/using-the-new-sharepoint-2010-ratings-feature-in-search.aspx)

Creating a new blog post
Blog posts created on your My Site are also social data in the newsfeed:

Why is a blog post social? Well, it how it’s used. A blog as a medium isn’t social per se: it’s just a mechanism to publish information, just like a news page is. The way we broadcast doesn’t necessarily make something social. However, most blog post show all the characteristics I like in the before mentioned paper by iCrossing:

it encourages contributions and feedback from everyone who is
interested.
it’s open to feedback and participation. Voting, comments and the sharing of information is encouraged.
it’s seen as a two-way conversation.
it’s community based (like this blog post is for the SharePoint community).

Please note that not all your blog posts will end up in the newsfeed: only the ones created under your My Site will appear. Postings in shared blogs (like a corporate blog), remain outside newsfeed unless you’ll write some custom code to add them. Allowing My Sites might not be something you had planned for.

When you’re on your My Site, there’s a shortcut to adding new blog posts:

The blog is a sub site of the My Site.

Useful links:

Plan for My Sites (http://technet.microsoft.com/en-us/library/cc262500.aspx)

User profile events or updates
Although user profile information is part of the social data realm, it is not really created like the categories above but is generated from updates to a profile or (automatic) events based on profile information.

When a user changes a profile property, this change is picked up and published to people who follow the user (see “Following colleagues” below for what that means in a SharePoint context) and have subscribed to a particular change category (like “Sharing Interests”).

The update is shown in the newsfeed:

Not only an active profile change ends up as an activity, also changing memberships, upcoming anniversaries or manager change generate an entry in the newsfeed.

A new feature in SharePoint 2010 is the status message, although under water it’s just a profile field called “Status message” (SPS-StatusNotes) that you cannot edit otherwise (not even from the user profile service application). The status message can be edited by yourself on the My Profile page:

The newsfeed and subscribing to activities
The newsfeed is somewhat similar to the Facebook wall but actually more similar to the LinkedIn “All updates”. It shows various types of activities, by you or by your colleagues. The newsfeed is available in two flavours:

Showing the activities from the colleagues you follow. The web part for this (What’s New) is on your My Newsfeed page (which is the default page of the My Site host)
Showing your activities. The web part for this (Recent Activities) is on the first tab of your profile page.

Following colleagues
You need to add a user as colleague to follow his or her activities. This can be done from the “My colleagues” pages in the My Site host:

Users that report to the same manager as you, are automatically added as your colleague, but this list can be edited manually. The button “View Suggestions” brings up suggested colleagues, like people who have tagged with your interest:

Once you have colleagues, you can follow their activities as set in the Newsfeed section of your profile. The following activities are available:

Note Board post
Tagging with my interests
Rating
Status Message
Manager change
New blog post
New membership
Sharing Interests
Tagging by my colleague
Upcoming birthday
Birthday
Upcoming workplace anniversary
Workplace anniversary
New colleague
Job title change
Profile update

Note: The “Tagging with my interests” activity is generated for all users, not just your colleagues.

What the newsfeed is not
What you’ll soon discover about the newsfeed, is that it’s not Facebook or Twitter:

You cannot “Like” an activity or write a comment on it. In SharePoint 2010, you like or comment content, not an activity
You cannot hash tag your notes. Well, you can put a hash sign in, but there’s no mechanism to pick it up. So that also means you don’t have notes in your newsfeed that contain words that match your interests.
It’s all but real time. New activities are picked up by a timer job running every hour (default setting), the newsfeed web part does not refresh without a page reload. You can set the jobs to run every minute, but that’s still far from real time.
You cannot “follow” any other entity than a colleague, so if you want to follow activities on a community site, you have to visit that site.

Social data in SharePoint 2010 is very much profile oriented and you’ll have to go to your or someone else’s profile page so see what’s cooking. So SharePoint social is a corporate LinkedIn, without an OOTB way to follow community activity.

A square peg in a round hole?
Does SharePoint 2010 social functionality make sense? Well, that depends on your needs. You might be just happy with a corporate LinkedIn, centered around user profiles.
If you’re searching for hash tagging, liking or leaving comments on activities and want social data centered around a community instead of a profile, SharePoint out-of-the-box will not satisfy your needs.

However, please appreciate that SharePoint takes security into account: you won’t see anything you don’t have access rights too. In the corporate world, securing content is often best practice but this comes with a price: if you want to build a knowledge platform using social media, preventing people from seeing activities is also keeping knowledge away from them. Just think of the case where your colleague tags something in a team site you don’t have access to. Should you still see the activity in your newsfeed?

So aren’t we asking too much of the platform? Full security and governance on one hand, full openness on the other. Structured data, retention policies and document management on on hand (a closed system), unstructured tagging, rating and comments on the other (an open system).
I don’t claim to have an exact answer to the paradox above as it’ll depend on the customer’s case. As long as you’re aware of the possibilities and consequences, you can provide the best solution. Hopefully, this blog post helps a little with that.

Useful links:

SharePoint Server 2010 Adoption Best Practices White Paper (http://www.microsoft.com/download/en/details.aspx?id=1288)
SharePoint Server 2010 Usage Best Practices White Paper (http://www.microsoft.com/download/en/details.aspx?id=12500)

Coming up
Now we’ve cleared level 100 and it’s time to move a little deeper into the mechanics of social data in SharePoint 2010, so check out the next posts in this series, coming soon.

Generically kick starting workflows for system account actions

2011-04-11T13:52:00.001+02:00

Since MOSS 2007 service pack 1, workflows are not automatically starting when the list item is created or modified by the system account. For a recent project, we implemented a generic workflow starter event receiver that kick starts workflows in certain conditions.

The event receiver does its trick for the ItemAdded and ItemUpdated events and calls a private method for the implementation:

public override void ItemAdded(SPItemEventProperties properties)
{
  StartWorkflows(properties, EventType.ItemAdded);
}

Please note that the EventType enum is project specific, it’s not standard SharePoint.

The private method StartWorkflows takes two properties:

the event properties

a custom enum value

First, a check is done if we can get the item id and the list name. This should never go wrong, but you never know…

int itemId = properties.ListItemId;
string listName = properties.ListTitle;
if (itemId == null || listName == null)
{
  return;
}

We now start running the code with elevated privileges. This is required to get the appropriate access to the item and its properties.

SPSecurity.RunWithElevatedPrivileges(delegate()
{
  using (SPSite ElevatedSite = new SPSite(properties.SiteId))
  {
    using (SPWeb ElevatedWeb = ElevatedSite.OpenWeb(properties.RelativeWebUrl))
    {
      SPList list = ElevatedWeb.Lists[listName];
      SPListItem item = list.GetItemById(itemId);

Next, a check is done if the item is a folder. In our scenario, nothing should be done with folders so we rule them out here:

if (item.Folder != null)
{
  return;
}

Now we check the account that added or modified the item:

string loginName;
if (eventType == EventType.ItemAdded)
{
  loginName = item.GetFieldValueUserLogin(SPBuiltInFieldId.Author);
}
else
{
  loginName = item.GetFieldValueUserLogin(SPBuiltInFieldId.Editor);
}

As you can see, we implemented an extension method (GetFieldValueUserLogin) to get the name:

public static string GetFieldValueUserLogin(this SPListItem item, Guid fieldId)
{
  if (item != null)
  {
    SPFieldUserValue userValue = new SPFieldUserValue(item.Web, item[fieldId] as string);
    return userValue.User.LoginName;
  }
  else
  {
    return string.Empty;
  }
}

We now call the code that actually fires the workflows. This is done with a helper method (for reuse purposes):

SharepointHelper.StartWorkFlow(ElevatedSite, list, item, loginName);

In the helper method, all workflow associations of the list are retrieved. if the workflow is of the type “AutoStartCreate” or “AutoStartChange”, a workflow will be started on the item. Here’s the code of the method:

public static void StartWorkFlow(SPSite site, SPList list, SPListItem item, string loginName)
{
  if (loginName.ToUpper() == "SHAREPOINT\\SYSTEM")
  {
    SPWorkflowManager workflowManager = site.WorkflowManager;
    SPWorkflowAssociationCollection workflowAssociations = list.WorkflowAssociations;
    foreach (SPWorkflowAssociation workflowAssociation in workflowAssociations)
    {
      if (workflowAssociation.AutoStartCreate || workflowAssociation.AutoStartChange)
      {
        workflowManager.StartWorkflow(item, workflowAssociation, workflowAssociation.AssociationData);
      }
    }
  }
}

In our scenario, the event receiver is added to a particular list by the event receiver that created the list. I haven’t tested this on SharePoint 2010 yet but will post an update if I do.

Files not indexed in custom default view

2010-10-02T19:11:00.001+02:00

One of the things I always set as a crawl rule is something like “http://*/Forms/*.aspx”. This will exclude all the list view pages from being indexed.

I never experienced a problem until recently, where some documents didn’t show up in the search results. The setup is a MOSS 2007 farm at a customer. It’s running a webapp with a single site collection and multiple (levels of) subsites.

In on of the sites, there is a library with a custom view set as default: “DocumentsByType.aspx” (the screen shot below is from a Dutch site, but you’ll get the idea). I’ve recreated it for this article with some dummy content. There are two documents in there:

Now when I search for these documents on a search page with a specific scope (after running a full crawl), I get results, but not the ones I expect:

So I get the site and the default page, which contains a list view web part of the document library. Hey, I want my documents in the results!

Elementary, dear Watson

After staring at this for a while, I checked various possible causes:

versioning. Nope, all docs were major versions
security. Nope, I’m logged in in God mode
library excluded from search results? Nope, indexing allowed.
Type of document? Nope, I have a doc and a docx. How standard can it be?

I expected to find relevant information in the crawl log, filtered on my library URL, but found none:

There’s nothing in the document library? Pull the other one, will you!

But wait, I have a crawl rule specified, remember? So I must have excluded all libraries. Well, surprisingly that isn’t the case. When searching in another scope, I do get results:

So what’s the difference between the library that returns results and the one that doesn’t? The view!

Take a different view: the default one

I happens that my libary has a default view that is not allitems.aspx (but “DocumentsByType.aspx”, remember?). After I change the “All documents” view (allitems.aspx) to be the default one and run a full crawl, I get the results I expect:

The crawl log also contains info now:

So what’s happening?

If you exclude forms pages in a library from being crawled, the items can’t be indexed. Remember that the indexer crawls over http, not over the object model. However, it seems there’s something special with the allitems.aspx because even if we set the crawl rule “http://*/Forms/*.aspx” and have the allitems.aspx page as the default view, it gets indexed.

It’s hard to find anything with reflector. The only thing I found that might be relevant is “Microsoft.Office.Server.Search.Administration.SearchAdminUtils.NormalizeUri(Uri)”, where the following code can be found:

if (builder.ToString().EndsWith("/allItems.aspx"))
{
  builder.Length -= LogsConstants.CWC_URL_ALLITEMS_ASPX;
}

If you fancy a deeper dive and find more info, share your knowledge. In the meantime, be careful with crawl rules and your default views.

Changing a site programmatically right after provisioning

2010-06-25T17:45:00.001+02:00

For a customer, I’ve designed a farm with several web applications. One of the web applications is used for ad-hoc collaboration sites, each running as a site collection in a managed path.

The collaboration sites are based on a Team site definition and need some extras:

a custom design
two extra navigation buttons: one called Home, to be shown as the first button, one called Search, to be shown as the last one. The result should be something like: [Home] [Start page] [Search]

A good practice is to use feature stapling (see http://msdn.microsoft.com/en-us/library/bb861862(office.12).aspx if you don’t know what this is) to achieve this. So I created two features:

a feature with receiver to set some properties programmatically
a stapling feature

The stapling feature consists of an elements file with a FeatureSiteTemplateAssociation element:

<FeatureSiteTemplateAssociation Id="[feature id]" TemplateName="MYTEMPLATE#0" />

The feature receiver sets some properties:

  1: public class WerkplaatsReceiver : SPFeatureReceiver
  2:     {
  3:         /// <summary>
  4:         /// Occurs after the Feature is activated. Navigation nodes are added and a custom CSS is applied.
  5:         /// </summary>
  6:         /// <param name="properties">An <see cref="T:Microsoft.SharePoint.SPFeatureReceiverProperties"></see> object that represents the properties of the event.</param>
  7:         [SharePointPermission(SecurityAction.LinkDemand, ObjectModel = true)]
  8:         public override void FeatureActivated(SPFeatureReceiverProperties properties)
  9:         {
 10:             try
 11:             {
 12:                 //Declare variables
 13:                 string newCSS = "";
 14:                 string searchCenterUrl = "";
 15:                 string searchCenterTitle = "";
 16:                 string homeUrl = "";
 17:                 string homeTitle = "";
 18:                 string portalName = "";
 19:                 string portalUrl = "";
 20:                 string featureId = properties.Feature.DefinitionId.ToString();
 21: 
 22:                 //Get the values for the properties. Check if they exist in the feature xml to avoid object reference errors.
 23:                 if (properties.Feature.Properties["CssLocation"] != null)
 24:                 {
 25:                     newCSS = properties.Feature.Properties["CssLocation"].Value;
 26:                 }
 27:                 if (properties.Feature.Properties["SearchCenterUrl"] != null)
 28:                 {
 29:                     searchCenterUrl = properties.Feature.Properties["SearchCenterUrl"].Value;
 30:                 }
 31:                 if (properties.Feature.Properties["SearchCenterTitle"] != null)
 32:                 {
 33:                     searchCenterTitle = properties.Feature.Properties["SearchCenterTitle"].Value;
 34:                 }
 35:                 if (properties.Feature.Properties["HomeUrl"] != null)
 36:                 {
 37:                     homeUrl = properties.Feature.Properties["HomeUrl"].Value;
 38:                 }
 39:                 if (properties.Feature.Properties["HomeTitle"] != null)
 40:                 {
 41:                     homeTitle = properties.Feature.Properties["HomeTitle"].Value;
 42:                 }
 43:                 if (properties.Feature.Properties["PortalName"] != null)
 44:                 {
 45:                     portalName = properties.Feature.Properties["PortalName"].Value;
 46:                 }
 47:                 if (properties.Feature.Properties["PortalUrl"] != null)
 48:                 {
 49:                     portalUrl = properties.Feature.Properties["PortalUrl"].Value;
 50:                 }
 51: 
 52:                 //get the site collection where the feature is activated
 53:                 using (var curSite = (SPSite)properties.Feature.Parent)
 54:                 {
 55:                     //Set the portal connection
 56:                     if (portalName != "" && portalUrl != "")
 57:                     {
 58:                         curSite.PortalName = portalName;
 59:                         curSite.PortalUrl = portalUrl;
 60:                     }
 61: 
 62:                     //Get a reference to the root web
 63:                     var curWeb = curSite.RootWeb;
 64: 
 65:                     //Set the path to the CSS
 66:                     curWeb.AlternateCssUrl = newCSS;
 67: 
 68:                     //Disable any theme
 69:                     curWeb.ApplyTheme("none");
 70: 
 71:                     //Set search center url
 72:                     curWeb.AllProperties["SRCH_ENH_FTR_URL"] = searchCenterUrl;
 73: 
 74:                     //Add navigation nodes as external nodes to make sure we don't get file not found exceptions
 75:                     SPNavigationNodeCollection topNavNodes = curWeb.Navigation.TopNavigationBar;
 76:                     if (topNavNodes != null)
 77:                     {
 78:                         if (homeTitle != "" && homeUrl != "")
 79:                         {
 80:                             SPNavigationNode homeNode = new SPNavigationNode(homeTitle, homeUrl, true);
 81: 
 82:                             //Add to nodes collection
 83:                             topNavNodes.AddAsFirst(homeNode);
 84: 
 85:                             //Add feature id so we can always remove these nodes on feature deactivate
 86:                             homeNode.Properties.Add("FeatureId", featureId);
 87:                             homeNode.Update();
 88:                         }
 89:                         if (searchCenterTitle != "" && searchCenterUrl != "")
 90:                         {
 91:                             SPNavigationNode searchCenterNode = new SPNavigationNode(searchCenterTitle, searchCenterUrl, true);
 92: 
 93:                             //Add to nodes collection
 94:                             topNavNodes.AddAsLast(searchCenterNode);
 95: 
 96:                             //Add feature id so we can always remove these nodes on feature deactivate
 97:                             searchCenterNode.Properties.Add("FeatureId", featureId);
 98:                             searchCenterNode.Update();
 99:                         }
100:                     }
101:                     
102:                     //Update the web
103:                     curWeb.Update();
104:                 }
105:             }
106:             catch (SPException)
107:             {
108:             }
109:         }

The feature.xml contains the properties:

<Properties>
    <Property Key="HomeUrl" Value="/pages/welcome.aspx"/>
    <Property Key="HomeTitle" Value="Home"/>
    <Property Key="SearchCenterUrl" Value="http://myfarm/searchcenter/"/>
    <Property Key="SearchCenterTitle" Value="Search"/>
    <Property Key="CssLocation" Value="/Style Library/collaboration.css"/>
    <Property Key="PortalName" Value="Collaboration"/>
    <Property Key="PortalUrl" Value="/"/>
  </Properties>

You might have noticed I’m adding navigation nodes with some extra properties (the feature Id). This is to make sure I can remove the nodes (even if they have changed!) when the feature is deactivated:

  1: public override void FeatureDeactivating(SPFeatureReceiverProperties properties)
  2:         {
  3:             //Declare variables
  4:             string featureId = properties.Feature.DefinitionId.ToString();
  5: 
  6:             try
  7:             {
  8:                 //get the site collection where the feature is deactivated
  9:                 using (var curSite = (SPSite)properties.Feature.Parent)
 10:                 {
 11:                     //Reset the portal connection
 12:                     curSite.PortalName = "";
 13:                     curSite.PortalUrl = "";
 14: 
 15:                     //Get the root web
 16:                     var curWeb = curSite.RootWeb;
 17: 
 18:                     //Reset the alternate CSS
 19:                     curWeb.AlternateCssUrl = "";
 20: 
 21:                     //Reset the URL to the common search center
 22:                     curWeb.AllProperties["SRCH_ENH_FTR_URL"] = "";
 23: 
 24:                     //Delete the navigation nodes that were added via this feature
 25:                     SPNavigationNodeCollection topNavNodes = curWeb.Navigation.TopNavigationBar;
 26:                     foreach (SPNavigationNode node in topNavNodes)
 27:                     {
 28:                         if (node.Properties.ContainsKey("FeatureId"))
 29:                         {
 30:                             if ((string)node.Properties["FeatureId"] == featureId)
 31:                             {
 32:                                 topNavNodes.Delete(node);
 33:                             }
 34:                         }
 35:                     }
 36: 
 37:                     //Update the web
 38:                     curWeb.Update();
 39:                 }
 40:             }
 41:             catch (SPException)
 42:             {
 43:             }
 44:         }

So far so good…

A problem with the order of events

Implementing this did not result in expected behaviour when it came to the navigation nodes: every time the order of the nodes was [Start page] [Home] [Search].

After a while, I realised that the order of events was working against me. When the site is created, the following takes place:

site features from the onet.xml

stapled site features

web features from the onet.xml

stapled web features

modules

The Start page is created from the modules section and therefore created after my feature is activated. I need a way to fire an event after the site is created, but there’s no site created event. Luckily, there is way: provisioning.

Provisioning to the rescue

Microsoft uses provisioning for its portal templates, to add extra sites. For my solution, I do not have to create a site hierarchy, just set some properties.

It’s actually fairly easy: create a provisioning class (see http://msdn.microsoft.com/en-us/library/microsoft.sharepoint.spwebprovisioningprovider.provision.aspx), override the Provision method and add a reference to it in the site configuration in the webtemp*.xml.

<?xml version="1.0" encoding="utf-8" ?>
<Templates xmlns:ows="Microsoft SharePoint">
  <Template Name="MYTEMPLATE" ID="12004">
    <Configuration ID="0" Title="collaboration site"
        Hidden="FALSE"
        ImageUrl="/_layouts/Images/collaborationsite.gif"
        Description="A collaboration site."
        RootWebOnly="TRUE"
        DisplayCategory="My company"
        ProvisionAssembly="[my assembly name], Version=1.0.0.0, Culture=neutral, PublicKeyToken=[my token]"
        ProvisionClass="CollaborationProvisioner">
    </Configuration>
    <Configuration ID="1" Title="collaboration site"
        Hidden="TRUE"
        ImageUrl="/_layouts/Images/collaborationsite.gif"
        Description="A collaboration site."
        RootWebOnly="TRUE"
        DisplayCategory="My company">
    </Configuration>
  </Template>
</Templates>

As you might have noticed, I have tow configurations. The first one is the one that fires the provisioning code, the second one is the actual configuration in the onet.xml. In code, I call the configuration with ID=1 to create the actual site. After that, I add the feature:

  1: public class CollaborationProvisioner : Microsoft.SharePoint.SPWebProvisioningProvider
  2:     {
  3:         public override void Provision(SPWebProvisioningProperties props)
  4:         {
  5:             //Apply template in a 'using' statement to make sure the SPWeb is available again for the feature receivers and for 
  6:             //persisting the applied template in the web object
  7:             using (var curWeb = (SPWeb)props.Web)
  8:             {
  9:                 //Apply the hidden template. The #0 is the one the end users see.
 10:                 curWeb.ApplyWebTemplate("MYTEMPLATE#1");
 11:             }
 12: 
 13:             //Get a reference to the site collection. Perhaps no need to dispose but not sure if we own the object 
 14:             //(also see http://solutionizing.net/2008/12/06/the-new-definitive-spsitespweb-disposal-article/)
 15:             using (var curSite = (SPSite)props.Web.Site)
 16:             {
 17:                 //Add the feature
 18:                 if (curSite.Features[new Guid("[my guid]")] == null)
 19:                 {
 20:                     curSite.Features.Add(new Guid("[my guid]"));
 21:                 }
 22:             }
 23:         }
 24:     }

A few important notes on this:

if you don’t call ApplyWebTemplate, you’ll need to choose one in the browser (which is strange for the user as he has already chosen one)

If you don’t use “using” or properly dispose the SPWeb after calling ApplyWebTemplate, the feature that is added on line 20 will generate an error as it cannot update the SPWeb because it’s still in use by the provision process

If with ApplyWebTemplate you call the same template as the one that has the provisioning class referenced, you’ll end up with an eternal loop

Anyway, this worked for me and triggered numerous ideas on what else you could do with this. Cool stuff anyway.

The power of the site directory

2010-04-23T09:14:00.001+02:00

Sites in SharePoint are often in a sort of logical parent/child relationship. For example, projects can be part of a program or related to a customer, units can be part of a division etc:

This logical relationship is often translated into a physical parent/child relationship in SharePoint using sites with sub sites:

In the example above, I think of the customer site being the root site of a site collection. In real life, there might be more levels above this, but the above assumption should give you an idea.

There are, however, some disadvantages with using sub sites:

each sub site might require very specific access rights. As all SharePoint groups are managed at the site collection level, the chance increase that security is not set properly
if you get a lot of sub sites, each with unique groups, the amount of groups to manage at the site collection level just explodes
in the example above, the root and sub sites have a complete different level of life cycle management. Whereas a project has a start and an end within a reasonable amount of time, a customer relation lasts a lot longer. To archive a finished project, you need to archive it with the customer as the sub site has dependencies on the site collection (for content types and site columns for example). Restoring an archived project also means restoring the site collection stuff, which might have changed dependencies.

Life cycle management is a worth writing a few more posts but for this one I’ll leave it to that.

using site collections

To overcome the disadvantages mentioned above, you can architecture your solution with site collections for your projects.

These site collections are created within a managed path and exist on the same physical level. Using site collections has some advantages:

a site collection has its own groups and because there are no sub sites (the assumption is that there are no sub projects), the amount of groups is manageable
a site collection has a natural security boundary so it’s easier to secure your data
a site collection can have its own database. When the site is no longer active and should be archived, this database can be detached from SQL, zipped and stored on tape

There are also some disadvantages:

you can have fewer sites than when using a combination of site collections with sub sites. However, looking at the absolute numbers, this seems a bit theoretical (please refer to http://technet.microsoft.com/en-us/library/cc262787.aspx for details).
you cannot aggregate data between site collections using the OOTB components like the Content Query web part
there is no physical connection between the sites, so there is no breadcrumb or URL to indicate the logical relationship

using the Site Directory as a logical relation store

Creating site collections can be done from the Central Admin or from the Sites Directory. This directory is based on, like almost everything in SharePoint, a list (called Sites) with items and metadata.

The pages in the Site Directory site just provide you a view on that list, using special web parts. When a new site is created, anywhere in a portal that has a Site Directory, the user can choose if a reference to that site should be stored as an item in that list. The user can also provide some extra metadata to make the site easier to find.

If self-service site creation is enabled, users with appropriate rights can create their own site collections. Make sure to enable the setting is the Site Directory settings page:

From the Site Directory home page, click the Create Site button

You’ll notice that you’ll be redirected to “_layouts/scsignup.aspx” instead of “_layouts/newsbweb.aspx”.

OK, so far the basic SharePoint stuff, let’s go back to the architecture. The key to using the Site Directory as a logical relation store is the metadata. If we take our customer/project relation, for example, we could store the reference to the customer as metadata with the entry of the project site.

One of the properties can be Customer. This field can be text, a choice list, a lookup to a list of customers or a custom field that queries the Sites list for entries of the type “customer site”.

The relationship is now stored and can also easily be changed without having to move the site around: just change the metadata!

Now that we know how to store the logical relationship, we still need to have a means of using that information. In the Site Directory itself, you can create a view on the list, grouped by customer:

On the home page, the categories web parts shows as follows:

advanced customizations

Specifying the customer might work for project sites, but might be completely irrelevant to other types (like a customer site). There might also be a other requirements:

a need to store some of our metadata in the site itself. You need to control the provisioning process to make this happen.
grant site creation rights for some site templates to specific users only. You need to replace the site creation page for this. Never touch the OOTB pages.
use the site directory for global navigation. We used this in a customer project, linking the site directory with a special custom list that was used to merge site data and other information into a navigation provider
implement security on who can see site references. You can achieve this by using item level security on the items in the Sites list

In any case, in the sites themselves we want to visualize the logical relationship to a parent:

in the breadcrumb
in the top navigation

All of this can only be achieved with custom development, for example with a custom navigation provider. Examples can be found, amongst others, on http://msdn.microsoft.com/en-us/library/bb897739.aspx and http://www.sharepointdev.net/sharepoint--development-programming/how-to-create-custom-sitemapprovider-inder-to-create-custom-navigation-60525.shtml.

There are many more possibilities but I’ll leave that up to your creativity. Hopefully, this post has triggered some ideas. If you have any, please share with the community!

CSS trick to indent text except for the first line

2010-03-29T22:11:00.001+02:00

This is a trick I used for a customer and for which I thought I needed a table element.

What I wanted to achieve is the following (in SharePoint that is):

retrieve a number of calendar items using de Content By Query (CBQ) web part
show the date and the title of the event
if the title is too long, display it on the next line but not under the the date

You could use something like the following (per row):

<tr>
 <td valign="top">[insert date here]</td>
 <td valign="top">[insert title here]</td>
</tr>

It’s ugly, but it works. However, by default the CBQ does not provide a table wrapper around each row of data and I wanted to avoid creating a custom contentquerymain.xslt. I do, however, have a custom itemstyle.xslt with the following xsl (shows only a part of the template):

<div class="BG_agendaitem">
 <a href="{$SafeLinkUrl}" class="BG_newsoverviewwptitle">
  <xsl:value-of select="$day"/>-<xsl:value-of select="$month"/>-<xsl:value-of select="$year"/>
   <span class="BG_agendaitemspacer">
    <xsl:text disable-output-escaping="yes">&amp;nbsp;</xsl:text>
   </span>
  <xsl:value-of select="@Title"/>
 </a>
</div>

I use the following CSS:

.BG_agendaitem{
margin-left:62px;
text-indent:-62px;
}
.BG_agendaitemspacer{
width:6px;
}

The div has a margin-left of 62px. This will display all text at that margin. The div also has a text-indent of –62px, which will compensate for the 62px margin-left, but only for the first line.

The result on the page is as follows:

As you can see, the text flow is right where it should be, without tables.

App pool timeouts while debugging

2010-02-01T10:29:00.001+01:00

This is one I encountered this weekend.

On my new dev VM, I was debugging some web part code. For some code blocks, debugging took some time, and more than once, I got the message that the IIS application was reset and debugging cancelled.

For those of you who debug for a living, you might now how to overcome this already, but for all others, here’s the cause and the solution.

The application pool has a setting called “Ping enabled”, which can be set to true or false. When set to true, the app pool periodically checks if the application is still alive. It uses the interval specified in “Ping maximum response time”, which defaults to 90 seconds.

When debugging takes more than 90 seconds, the app pool thinks that the application is not responsive anymore and recycles.

If you set Ping Enabled to false, your debug can take as long as you need. If that’s a bit too scary for you, specify a higher interval.

Playing around with custom fields, part 3

2010-01-17T17:37:00.001+01:00

This is part 3 of a blog series on custom fields.

Part 1
Part 2

This article will contain the final bits of the solution: a custom field to display rating info. Please note that this is not a complete product I’m presenting, but my findings on a journey to learn more about custom fields. I do hope it’ll trigger ideas you can apply in your own solution.

How the field works

There are a few steps involved:

creating an instance of the field. This field is a number field and stores a rating value
calling the OnAdded method to set some properties and fire some other methods
create a related field
modify the view

When a user creates a new field of this type, under water a related field is added to do the actual rendering. This new field will take the title of the field created (so the user won’t notice it), while the original field’s title will be changed. The related field will get a display pattern set via code and is added to the default view. The original field is removed from the default view.

Creating an instance of the field

The field is instantiated with two constructors:

  1:     public RatingField(SPFieldCollection fields, string fieldName)
  2:       : base(fields, fieldName)
  3:     {
  4:       this._fields = null;
  5:       this._fields = fields;
  6:       this.DisplayFormat = SPNumberFormatTypes.NoDecimal;
  7:     }
  8: 
  9:     public RatingField(SPFieldCollection fields, string fieldName, string displayName)
 10:       : base(fields, fieldName, displayName)
 11:     {
 12:       this._fields = null;
 13:       this._fields = fields;
 14:       this.DisplayFormat = SPNumberFormatTypes.NoDecimal;
 15:     }

Why do you need two? Please refer to the previous post for a reference to some good articles.

The class also has some private variables to be used later:

  1:     private SPFieldCollection _fields;
  2:     private String _renderFieldSuffix = "_EOGRatingRenderField";
  3:     private String _renderFieldDisplayName = "";
  4:     private String _fieldNewDisplayNamePrefix = "Rating value for ";

Here’s what they do:

The SPFieldCollection _fields is used in a method to delete the related field when the field itself is deleted.

The string _renderfieldSuffix is used to make sure the related field created later has a standard naming convention

The string _renderfieldDisplayName is used to set the title of the rendered field

The string _fieldNewDisplayNamePrefix is used to set a display value for the field in the view

OK, nothing really exiting here, so let’s move on.

Calling the OnAdded method

If you have read the articles I mentioned above, you’ll know that setting properties in the constructors is of no use. The OnAdded method is the place to be for setting anything custom and will fire once the control has been added. This method takes one parameter of the enum type SPAddFieldOptions but for this solution I’m not going to use it.

  1: public override void OnAdded(SPAddFieldOptions op)
  2: {
  3:  SPList list = this.ParentList;
  4: 
  5:  if (list != null)
  6:  {
  7:   //change display name of field
  8:   _renderFieldDisplayName = this.Title;
  9:   this.Title = _fieldNewDisplayNamePrefix + _renderFieldDisplayName;
 10:   this.Update(true);
 11: 
 12:   //create related field
 13:   CreateRelatedField();
 14: 
 15:   //hide field from default view
 16:   HideFieldFromDefaultView(this.InternalName);
 17:  }
 18: }

The following actions are performed here:

setting the value of the _renderfieldDisplayName variable. The rendered field should gets the title the user specified when creating the field so we copy it from this.Title.

change the title of the field to add the prefix set in the variable _fieldNewDisplayNamePrefix.

Update the field to make the changes persistent

Create the related field by calling the custom method CreateReleatedField

Hide the original field from the default view by calling the custom method HideFieldFromDefaultView.

If the field is created as a site column, there is no use for a related field and there is no view to modify. Only when the field is instantiated to a list, further actions are required. Remember, when a site column is applied to a list, a copy is made so the OnAdded will be called again. Check if the field (“this”) has a ParentList. If not, no further actions required.

Creating the related field

The method CreateRelatedField() creates the related field and adds it to the default view.

  1: private void CreateRelatedField()
  2: {
  3:   SPList list = this.ParentList;
  4: 
  5:   String relatedFieldName = this.InternalName + _renderFieldSuffix;
  6: 
  7:   //Now create a new field of the type Computed. This allows us to separate rendering from the actual fields that store the values.
  8:   string fieldSchema = "<Field Type=\"Computed\" ReadOnly=\"TRUE\" Name=\"" + relatedFieldName + "\" DisplayName=\"" + relatedFieldName + "\" Sortable=\"TRUE\" Filterable=\"TRUE\" EnableLookup=\"FALSE\" SourceID=\"http://schemas.microsoft.com/sharepoint/v3\"><FieldRefs><FieldRef Name=\"" + this.InternalName + "\" /></FieldRefs><DisplayPattern><Switch><Expr><Column Name=\"" + this.InternalName + "\"/></Expr><Case Value=\"\"><HTML><![CDATA[<img src=\"_layouts/images/eog_rating/rating0.gif\" onclick=\"commonShowModalDialog(']]></HTML><HttpVDir/><HTML><![CDATA[/_layouts/Eog_RatingField/Eog_rating.aspx' ,'dialogHeight:150px;dialogWidth:180px;scroll:no;toolbar:no;status:no;resizable:no;',null, this.parentNode);\" />]]></HTML></Case><Default><HTML><![CDATA[<img src=\"_layouts/images/eog_rating/rating]]></HTML><Column Name=\"" + this.InternalName + "\"/><HTML><![CDATA[.gif\" />]]></HTML></Default></Switch></DisplayPattern></Field>";
  9:   list.Fields.AddFieldAsXml(fieldSchema);
 10: 
 11:   //Due to a bug in SharePoint, the field had to be created with a DisplayName the same as Name. After creation, we can update the field DisplayName
 12:   SPField field = list.Fields[relatedFieldName];
 13:   field.Title = _renderFieldDisplayName;
 14:   field.Update(true);
 15: 
 16:   //add field to default view
 17:   SPView view = list.DefaultView;
 18:   if (!view.ViewFields.Exists(relatedFieldName))
 19:   {
 20:     view.ViewFields.Add(relatedFieldName);
 21:     view.Update();
 22:   }
 23: }

The following actions are performed here:

create a Name for the related field that is related to the field the user created. Remember our CAML constraint mentioned in the previous post? If we know the Name set by the user, we can reference it. By using a standard naming conventions, we can always reference it, even from CAML.

create a new field of the type Computed. This allows us to separate rendering from the actual fields that store the values. Please note that my solution does not contain all the required fields for a full rating solution, but this code demonstrates how to do it.

create this field by calling list.Fields.AddFieldAsXml using a string of XML. The reason for creating a field this way is that we have control over the field properties and can set the DisplayPattern dynamically. See http://murugangs.blogspot.com/2007/12/checkbox-in-listviewwebpart.html for an example of setting the DisplayPattern.

set the display name (=Title) to the correct value. Due to a bug in SharePoint, the field had to be created with a DisplayName the same as Name. See http://weblogs.asp.net/bsimser/archive/2005/07/21/420147.aspx for details

Add the field to the default view. You need to create a View object first; setting the property directly via list.DefaultView.ViewFields.Add() does not work! While writing this post and thinking about how to explain why this works the way it does, I found an excellent article by Keith Dahlby on http://solutionizing.net/2009/02/21/why-you-need-reflector-splist-defaultview/. For a briefer explanation, see http://stackoverflow.com/questions/776367/customizing-pages-view-in-sharepoint%20for%20details.

As you can see, I’m now using CAML set via code. This overcomes the issues of not being able to manipulate it as mentioned in the previous post.

Hiding the original field

As the original field is only used as a store for the rating value, we don’t need to show it in the view. The method HideFieldFromDefaultView() will take care of it.

  1: private void HideFieldFromDefaultView(String internalName)
  2: {
  3:   SPList list = this.ParentList;
  4: 
  5:   //We need to create a view object due to an issue of fields collection getting out of scope
  6:   SPView view = list.DefaultView;
  7:   if (view.ViewFields.Exists(internalName))
  8:   {
  9:     view.ViewFields.Delete(internalName);
 10:     view.Update();
 11:   }
 12: }

The method takes the InternalName of the original field as input parameter, checks if it exists in the view (might not be added due to user’s choice), deletes it from the view and then updates the view.

Cleaning up when the field is deleted

If a user deletes the field, we need to make sure the related field is deleted as well. We can use the OnDeleting() method to intercept a delete event:

  1: public override void OnDeleting()
  2: {
  3:   String relatedFieldInternalName = this.InternalName + _renderFieldSuffix;
  4:   DeleteRelatedField(relatedFieldInternalName);
  5: }

We need to know the internal name for the related field and luckily we have used a naming convention for this: this.InternalName + _renderFieldSuffix;

We now call the custom method DeleteRelatedField() which takes the internal name as input parameter:

  1: private void DeleteRelatedField(string internalName)
  2: {
  3:   if (this._fields.ContainsField(internalName))
  4:   {
  5:     SPField field = this._fields.GetFieldByInternalName(internalName);
  6:     field.ReadOnlyField = false;
  7:     field.Hidden = false;
  8:     field.Update();
  9:     this._fields.Delete(internalName);
 10:   }
 11: }

Here we use the _fields variable, which contains the fields collection related to the original field. We could have used the field collection of the list, but the collection is available from the field itself. If the field exists (it should, but you never know), a reference to the field is made, ReadOnly and Hidden are set to false, the field is updated and then deleted.

That’s all folks

Well, there you have it: a sample solution you could use as a reference for your own solutions. I hope it’ll be of use to you. For your convenience, the full code is listed below. Have fun!

  1: using System;
  2: using System.Collections.Generic;
  3: using System.Linq;
  4: using System.Text;
  5: using Microsoft.SharePoint;
  6: using System.Xml;
  7: 
  8: namespace Eog.SharePoint2007.Fields
  9: {
 10:   class RatingField : SPFieldNumber
 11:   {
 12:     #region private variables
 13:     private SPFieldCollection _fields;
 14:     private String _renderFieldSuffix = "_EOGRatingRenderField";
 15:     private String _renderFieldDisplayName = "";
 16:     private String _fieldNewDisplayNamePrefix = "Rating value for ";
 17:     #endregion
 18: 
 19:     #region constructors
 20:     public RatingField(SPFieldCollection fields, string fieldName)
 21:       : base(fields, fieldName)
 22:     {
 23:       this._fields = null;
 24:       this._fields = fields;
 25:       this.DisplayFormat = SPNumberFormatTypes.NoDecimal;
 26:     }
 27: 
 28:     public RatingField(SPFieldCollection fields, string fieldName, string displayName)
 29:       : base(fields, fieldName, displayName)
 30:     {
 31:       this._fields = null;
 32:       this._fields = fields;
 33:       this.DisplayFormat = SPNumberFormatTypes.NoDecimal;
 34:     }
 35:     #endregion
 36: 
 37:     #region events
 38:     /// <summary>
 39:     /// OnAdded event
 40:     /// </summary>
 41:     /// <param name="op"></param>
 42:     public override void OnAdded(SPAddFieldOptions op)
 43:     {
 44:       SPList list = this.ParentList;
 45: 
 46:       if (list != null)
 47:       {
 48:         //change display name of field
 49:         _renderFieldDisplayName = this.Title;
 50:         this.Title = _fieldNewDisplayNamePrefix + _renderFieldDisplayName;
 51:         this.Update(true);
 52: 
 53:         //create related field
 54:         CreateRelatedField();
 55: 
 56:         //hide field from default view
 57:         HideFieldFromDefaultView(this.InternalName);
 58:       }
 59:     }
 60: 
 61:     /// <summary>
 62:     /// OnDeleting event
 63:     /// </summary>
 64:     public override void OnDeleting()
 65:     {
 66:       String relatedFieldInternalName = this.InternalName + _renderFieldSuffix;
 67:       DeleteRelatedField(relatedFieldInternalName);
 68:     }
 69:     #endregion
 70: 
 71:     #region methods for hidden related data field
 72:     private void CreateRelatedField()
 73:     {
 74:       SPList list = this.ParentList;
 75: 
 76:       String relatedFieldName = this.InternalName + _renderFieldSuffix;
 77: 
 78:       //Now create a new field of the type Computed. This allows us to separate rendering from the actual fields that store the values.
 79:       //See http://murugangs.blogspot.com/2007/12/checkbox-in-listviewwebpart.html for an example of setting the DisplayPattern
 80:       //Create the field by calling AddFieldAsXml using a string of XML. The reason for creating a field this way is that 
 81:       //we have control over the field properties and can set the DisplayPattern dynamically.
 82:       string fieldSchema = "<Field Type=\"Computed\" ReadOnly=\"TRUE\" Name=\"" + relatedFieldName + "\" DisplayName=\"" + relatedFieldName + "\" Sortable=\"TRUE\" Filterable=\"TRUE\" EnableLookup=\"FALSE\" SourceID=\"http://schemas.microsoft.com/sharepoint/v3\"><FieldRefs><FieldRef Name=\"" + this.InternalName + "\" /></FieldRefs><DisplayPattern><Switch><Expr><Column Name=\"" + this.InternalName + "\"/></Expr><Case Value=\"\"><HTML><![CDATA[<img src=\"_layouts/images/eog_rating/rating0.gif\" onclick=\"commonShowModalDialog(']]></HTML><HttpVDir/><HTML><![CDATA[/_layouts/Eog_RatingField/Eog_rating.aspx' ,'dialogHeight:150px;dialogWidth:180px;scroll:no;toolbar:no;status:no;resizable:no;',null, this.parentNode);\" />]]></HTML></Case><Default><HTML><![CDATA[<img src=\"_layouts/images/eog_rating/rating]]></HTML><Column Name=\"" + this.InternalName + "\"/><HTML><![CDATA[.gif\" />]]></HTML></Default></Switch></DisplayPattern></Field>";
 83:       list.Fields.AddFieldAsXml(fieldSchema);
 84: 
 85:       //Due to a bug in SharePoint, the field had to be created with a DisplayName the same as Name. After creation, we can update the field DisplayName
 86:       //See http://weblogs.asp.net/bsimser/archive/2005/07/21/420147.aspx for details
 87:       SPField field = list.Fields[relatedFieldName];
 88:       field.Title = _renderFieldDisplayName;
 89:       field.Update(true);
 90: 
 91:       //add field to default view
 92:       SPView view = list.DefaultView;
 93:       if (!view.ViewFields.Exists(relatedFieldName))
 94:       {
 95:         view.ViewFields.Add(relatedFieldName);
 96:         view.Update();
 97:       }
 98:     }
 99:     #endregion
100: 
101:     #region private methods
102:     /// <summary>
103:     /// Hide a field from the default view of a list
104:     /// </summary>
105:     /// <param name="internalName">Internal name of the field</param>
106:     private void HideFieldFromDefaultView(String internalName)
107:     {
108:       SPList list = this.ParentList;
109: 
110:       //We need to create a view object due to an issue of fields collection getting out of scope
111:       //See http://stackoverflow.com/questions/776367/customizing-pages-view-in-sharepoint for details
112:       SPView view = list.DefaultView;
113:       if (view.ViewFields.Exists(internalName))
114:       {
115:         view.ViewFields.Delete(internalName);
116:         view.Update();
117:       }
118:     }
119: 
120:     /// <summary>
121:     /// Delete a related field
122:     /// </summary>
123:     /// <param name="internalName">Internal name of the field</param>
124:     private void DeleteRelatedField(string internalName)
125:     {
126:       if (this._fields.ContainsField(internalName))
127:       {
128:         SPField field = this._fields.GetFieldByInternalName(internalName);
129:         field.ReadOnlyField = false;
130:         field.Hidden = false;
131:         field.Update();
132:         this._fields.Delete(internalName);
133:       }
134:     }
135:     #endregion
136:   }
137: }

Custom PeoplePicker with security

2010-01-09T17:35:00.002+01:00

background
I’ve been working as architect on a very interesting and challenging SharePoint project for a few months now. The technical project lead asked me for advise on an issue concerning the PeoplePicker. Due to some issues in the past, where users accidentally added large AD groups to SharePoint groups and send notifications to hundreds of people, the PeoplePicker was set (using STSADM) to show only individual users and not AD groups. However, for some admin operations (like adding AD groups to SharePoint groups on some site) and for using the Axceler ControlPoint tools, adding AD groups was required. That’s a challenge, because there’s no way to configure the PeoplePicker for admin pages, only when using it as a People and Groups field in a list. As I want to keep my dev skills up-to-date, I put on my dev hat and created a solution.

modifying the people picker
Modifying the People Picker itself actually proved to be one of the easiest. It’s a matter of writing an override web control that inherits from Microsoft.SharePoint.WebControls.PeopleEditor and then setting the SelectionSet property in the OnLoad. SelectionSet is a comma separated string with four possible values. See http://msdn.microsoft.com/en-us/library/microsoft.sharepoint.webcontrols.peopleeditor.accounttype.aspx for details.

1: namespace ShareSP.PeoplePicker.WebControls
2: {
3:   public class PeopleEditor : Microsoft.SharePoint.WebControls.PeopleEditor
4:   {
5:     protected override void OnLoad(System.EventArgs e)
6:     {
7:       base.OnLoad(e);
8: 
9:       if(SPContext.Current.Web.UserIsSiteAdmin)
10:       {
11:         this.SelectionSet = "DL, SecGroup, SPGroup, User";
12:       }
13:       else
14:       {
15:         this.SelectionSet = "SPGroup, User";
16:       }
17:     }
18:   }
19: }

The above example is pretty simple. For my final solution, I added a lot more so keep on reading…

I’ve implemented this as a feature with web application scope. I’m not going to explain how to build this and add it to the GAC, use your favorite search engine to find the excellent articles that have been written about this if you don’t know how to do it. All source code is available on CodePlex.

replacing the existing PeoplePicker
Now that I have a custom PeoplePicker, how do I replace the existing one? Remember, the requirement is that it’ll be used on existing admin pages and we all know you should never edit default SharePoint files! Luckily, there is a very non-intrusive way. Years ago, my team at e-office developed a first version of a List web part. After a while, we did some serious rework on it and published a 2.0. The issue with web parts on pages is that the full reference is stored, so if you upgrade, the web page will still reference the old one. To avoid having to create an upgrade script for a few (but critical) instances, the web.config is our savior: you can use so called “tag mapping” to redirect an assembly reference to another. See http://msdn.microsoft.com/en-us/library/ms164641.aspx for reference or http://www.usingnat.net/sharepoint/2009/6/2/sharepoint-people-picker-override-validation-logic.html for an article on another custom PeoplePicker (make sure to read the comments as well as some extra stuff is required to get tag mapping to work).
I build all of this in a feature receiver that modifies the web.config when the feature is activated on a web application:

1: private void deployPeoplePicker(SPWebApplication webApp, string ownerID)
2:     {
3:       //Add Assembly
4:       string modificationName = string.Format(@"add[@assembly='{0}']", Assembly.GetExecutingAssembly().FullName);
5:       SPWebConfigModification modification = new SPWebConfigModification(modificationName, Globals.WebConfigModificationAssemblyPath);
6:       modification.Path = Globals.WebConfigModificationAssemblyPath;
7:       modification.Value = string.Format(@"<add assembly=""{0}"" />", Assembly.GetExecutingAssembly().FullName); ;
8:       modification.Owner = ownerID;
9:       modification.Sequence = 0;
10:       modification.Type = SPWebConfigModification.SPWebConfigModificationType.EnsureChildNode;
11:       webApp.WebConfigModifications.Add(modification);
12: 
13:       //Add tagMapping
14:       modificationName = string.Format(@"add[@tagType='Microsoft.SharePoint.WebControls.PeopleEditor'][@mappedTagType='ShareSP.PeoplePicker.WebControls.PeopleEditor,{0}']", Assembly.GetExecutingAssembly().FullName);
15:       modification = new SPWebConfigModification(modificationName, Globals.WebConfigModificationTagMappingPath);
16:       modification.Path = Globals.WebConfigModificationTagMappingPath;
17:       modification.Value = string.Format(@"<add tagType=""Microsoft.SharePoint.WebControls.PeopleEditor"" mappedTagType=""ShareSP.PeoplePicker.WebControls.PeopleEditor,{0}"" />", Assembly.GetExecutingAssembly().FullName);
18:       modification.Owner = ownerID;
19:       modification.Sequence = 1;
20:       modification.Type = SPWebConfigModification.SPWebConfigModificationType.EnsureChildNode;
21:       webApp.WebConfigModifications.Add(modification);
22: 
23:       //Save changes
24:       webApp.Farm.Services.GetValue<SPWebService>().ApplyWebConfigModifications();
25: 
26:       //Serialize and propagate changes across farm
27:       webApp.Update();
28: 
29:       //Create the persistent objects
30:       Common.CreatePersistentObjects(webApp);
31:     }

This stuff can be very tricky: the modification Path, for example, is an Xpath expression, but so is the Name attribute! I found some good guidance on Mark Wagner’s blog (http://www.crsw.com/mark/Lists/Posts/Post.aspx?ID=32) but still had to experiment a wee bit to get it working properly.

In the code above, the value for Modification.Owner is the Guid of the feature ID. This will make sure it’s unique and that the modifications can be retrieved for retract later.

When the feature is activated, the PeoplePicker is now showing different results for different users.
Admin users:

Common users:

adding more options

Basically, my solution worked. As I was in the “zone”, I decided to add some more features to make it more stable and easier to deploy and maintain. This is what I did:

added an admin page that allows admin users to set options for a web application. The admin page is accessible via Application Management in the Central Admin.
added retract methods in the feature receiver
split my code into several classes (and files)

Here’s what the admin page looks like:

All source files and the complete wsp are available on CodePlex: http://sharesp.codeplex.com/. Feel free to use or improve!

passed 70-542

2010-01-09T14:58:00.001+01:00

I’d studied for this last year but never had the time to do the exam. So when my team at e-office needed one more certificate for an area in our gold partnership, I immediately booked the exam. Two days later, I managed to pass with a score of 100%! That’s all 4 SharePoint exams in the pocket, now let’s get moving on the 2010 ones!

Publishing Image does not get indexed

2009-12-03T11:28:00.001+01:00

This is a nasty one if you want to use search to get publishing content displayed somewhere.

The short version

Here’s the short version if you’re not interested in the full monty:

On an article page, you can set an image in a field of the type “Publishing Image”. If you want to display this image in the search results, you’d expect you can use the “ows_PublishingPageImage” property to map in a managed property. Well, this won’t work. Microsoft Support doesn’t call it a bug (“SharePoint cannot crawl the content of a compound control”)and suggests, as a workaround, to store the ImageUrl value in another field using an event handler and then to map this field in a managed property.

Background

The problem first showed at a customer where article pages created in one site collection should be show in another. The configuration of the farm is like the following:

Note: this only conceptually reflects the infrastructure.

In Site collection 1, there is a site with a pages library. In this page library, pages with the content type Article Page (standard MOSS content type and page layout) are created for news.

Article created in the page library on Site collection 1 should be shown in Site collection 2 (without content deployment). As there is a boundary between site collections, the search index is used to make content from site collection available in the other. All users have at least read rights on all site collections.

Using either the default Search Core Results web part or a third party web part, it proved impossible to show the page image and roll up image in Site collection 2. The title and page content were shown without problems.

The next section shows repro steps taken.

Repro steps

For reproducing the problem, only one site collection is required as it will show the problem as well.

In the site collection, use a page library to store the Welcome or Article pages (both can be used for this scenario).

Each page has at least the following fields filled:

page content --> stored in the field “Page Content” (internal name: PublishingPageContent)
image --> stored in the field “Page Image” (internal name: PublishingPageImage)
roll up image --> stored in the field “Rollup Image” (internal name: PublishingRollupImage)

The images are displayed on the page by the standard Publishing Image control in the page layout (out of the box). The images are stored in an image library in Site collection 1. For testing purposes, images of both the default created image library “/PublishingImages/” and a newly created image library called “Pictures” (/Pictures) were used.

Below is a screenshot of the page properties of the page used for testing:

The page used for testing was published as a major version.

After that, the index was run with an incremental crawl. When searching for the word “welcome”, the Search Center displays the results correctly:

What I want to achieve now, is to show the Page Image (field: PublishingPageImage) instead of the icon. At my customer, I’m using a third party web part to display the articles, but the concept can be shown by using only standard functionality.

To make this possible, a few steps need to be followed:

create a managed property mapping to the page field
run a full crawl on the index
change the Core Results web part settings to include the new managed property as a column
change the XSLT for the search result to render an image using the new column

Step 1

In the SSP, I created a managed property called PublishingPageImage. This property maps to the indexed field ows_PublishingPageImage:

Note: the name of the managed property should match the mapped property as closely as possible to avoid problems.

Step 2

To make this managed property usable, a full crawl should be done. After the full crawl, you can already see the problem:

There are no items found using this property. However, as you can see in the page properties (first screen shot under Repro steps), the field does have a value!

Conclusion: the field ows_PublishingPageImage is not indexed properly!

Step 3

Steps 3 and 4 are actually obsolete as step 2 already shows us no content will be returned. However, to get the picture, I’ll show them anyway.

In the site collection Search Center, go to edit mode and go to the properties of the web part Search Core Results. Under Results Query Options, Selected Columns, open the columns editor and add

This will ensure our new managed property can actually be used in the search results. Click OK to close the editor dialog.

Step 4

In the web part property pane, click the XSL Editor button. In the editor, search for

     <span class="srch-Icon"> 

    <a href="{$url}" id="{concat('CSR_IMG_',$id)}" title="{$url}">

    <img align="absmiddle" src="{imageurl}" border="0" alt="{imageurl/@imageurldescription}" />

    </a>

    </span>

This text displays the default icon .

What I want to achieve is that the publishing page image is shown, when available. To do so, replace the xsl text above with something like the following:

    <xsl:if test=” publishingpageimage != ‘’”>

     <img>

      <xsl:attribute name=”src”> 

       <xsl:value-of select="publishingpageimage"/>

      </xsl:attribute>

     </img>

    </xsl:if>

    <xsl:if test=” publishingpageimage = ‘’”>

     <span class="srch-Icon"> 

      <a href="{$url}" id="{concat('CSR_IMG_',$id)}" title="{$url}">

      <img align="absmiddle" src="{imageurl}" border="0" alt="{imageurl/@imageurldescription}" />

     </a>

     </span>

    </xsl:if>

Note: as step 2 already makes sure we don’t get any results, it’s not sure if the creating an <img> is necessary. If the field stores complete html , the following would be OK:

    <xsl:if test=” publishingpageimage != ‘’”>

     <xsl:value-of select="publishingpageimage"/>

    </xsl:if>

    <xsl:if test=” publishingpageimage = ‘’”>

     <span class="srch-Icon"> 

      <a href="{$url}" id="{concat('CSR_IMG_',$id)}" title="{$url}">

       <img align="absmiddle" src="{imageurl}" border="0" alt="{imageurl/@imageurldescription}" />

      </a>

     </span>

    </xsl:if>

Click OK, and Apply. Click OK on the web part tool pane to close it.

The expected result would be that the image of the page is shown in the results

Other information

Please note that the images themselves (as library items) can be found with the search. The problem is the page field, creating the link between the page and the image. It looks like this field is not indexed properly, making it impossible to show images related to an article via Search.

Please note that if we use an out of the box picture field (not the publishing image), the contents are stored and indexed. However, this is not the behavior we want as we want to use the publishing features, not the WSS types.

Solution from Microsoft

For this problem, I opened a support case that ran for ages. After almost a year (!) mailing back and forth, I got the following solution:

Dear Sjoert,

As agreed your existing support case SRQ[…] will now be archived. Customer Satisfaction is very important to us and we would like to be sure that you are very satisfied with the service you have received.

If I can be of any further assistance on this case or if you have any suggestions for improving our service please do not hesitate to contact myself or my manager […] so we can ensure you receive our immediate attention.

Here is a summary of your case:

[ARCR]

ACTION:

You want to customize Search results Page, so that found pages are listed with an Image which is stored in the Web Part "Page Image".

You mapped the ows_PublishingPageImage with the internal name "PublishingPageImage" of the web part "Page image".

You also customized the web part "Search Core Results", so that the query returns also the mapped property "ows_PublishingPageImage" and modified the XSLT of this web part, so that it should additionally display the "PublishingpageImage" as a picture left of the url of the page.

RESULT:

The Image in the "Page Image" of the found page is not displayed in the Search Core results web part.

CAUSE:

The mapped property "ows_PublishingPageImage" is not crawled in that way, that we can use it as an image blob. SharePoint cannot crawl the content of a compound control.

RESOLUTION:

Workaround: You need to add the url to the image to the Pages Library List. We used the column "comment" for that purpose. We provided an EventHandler which receives and handles the events "ItemUpdating" and "ItemAdding" events(executed if you change or add a picture to the picture library).

public override void ItemUpdated(SPItemEventProperties properties)

{

SPListItem item = properties.ListItem;

string imageUrl = ((Microsoft.SharePoint.Publishing.Fields.ImageFieldValue)(item["PublishingPageImage"])).ImageUrl;

item["Comments"] = imageUrl;

item.Update();

}

Use this picture library for adding picture to the web parts "Page Image" or "Rollup Image".

Run a full crawl. Map the meta property ows_Comment to the column "Comment". Run a crawl again. Used this property name in the Search results Core Web Part in the query options and modify the XSLT.

Conclusion

I still think this is a bug: SharePoint cannot crawl the content of a compound control. However, there’s a workaround. I suggest not to use the Comments field as suggested by Microsoft but a dedicated field instead.

Installing SharePoint Foundation 2010

2009-11-19T15:14:00.001+01:00

I’ve been insatlling SharePoint Foundation 2010 beta today and although some blogs are already out there with good support on installation, I thought it might be handy to provide some visuals. Might be helpfull if you’re about to install or just want to know what it looks like without installing it yourself.

Development machine

I’m running VMWare Workstation on a Lenovo T61p with 4GB of Ram. Windows Server 2008 R2 is my OS on the VM and I had all prerequisites installed, including SQL Server, before making a linked clone on which I’m now installing SharePoint Foundation. Using a linked clone is a good thing: if the installation fails, you have a base VM to start over again.

Starting the installation

When you run the executable, the SharePoint Foundation installation window opens, offering a few options:

If your machine does not have all prerequisites installed, be sure to start with the option “Install software prerequisites”. Might also be a good idea to check Ji Lie’s blog post for some inportant hotfixes. Please note that the WCF fix he mentions for R2 is not available yet. However, things seem to install fine on my R2 machine!

Install software prerequisites

I was pretty sure I installed the lot, but you never know. So I started the installation of the prerequisites, which takes you into a wizard that tells you what is going to be done. Nice!

Next step is to accept the license agreement. Did I actually read it?

Select and click Next, which starts the various checks and installations. This will take a few minutes, depending on how well you prepared your machine. When it’s done, you get to the “Installation Complete” screen. Why do Americans start every word with a capital? Are they German?

Click Finish to return to the main setup screen. Now click “Install SharePoint Foundation”.

Installing Foundation

The installation wizard will first take you to the license terms:

Select and click Continue. You get to a screen with an important choice to make:

I strongly recommend you choose Server Farm. Standalone will use SQL Express, which has limited functionality. After clicking “Server Farm”, you’re faced with basically the same choice:

Select “Complete” and click the tab “Data location”. Here you can set the location of the index files. I recommend you choose a location not on the C drive:

Click “Install Now” to start the actual installation:

When all is fine, you get to the last screen of the installation wizard. Check the checkbox and click “Close” to start the configuration wizard:

Running the configuration wizard

The wizard starts with a welcom. Click “Next” to continue:

The wizard asks you if some services might have to be started or reset. Click “Yes”:

You are now asked if you want to connect to an existing farm or create a new one. I presume this is the first time you create one with SharePoint Foundation, so select “Create a new server farm”:

You are now asked to fill in some details for the database settings:

The next thing to fill in, is a passphrase for new servers to join the farm:

Make sure the passphrase is secure enough (using capitals, numbers and special characters). If your passphrase is not secure, you’ll get an error message:

The next screen asks you some settings for the Central Admin, like port number and authentication provider (NTLM or Kerberos):

Click “Next” to get to the summary page:

If you click the “Advanced Settings” button, you are taken to a screen to enable AD account creation mode:

Back in the summary screen, click “Next” to start the actual configuration. This might take some time:

When all goes well, you’re taken to the last screen in the wizard:

Click “Finish” to close the wizard and to be taken to the Central Admin page.

Central administration

When going to the Central Admin for the first time, the first question you’re asked is if you want to participate in the customer experience improvement program:

Of course you want to, to make a great product even better!. Click “OK” to move on. You’re now asked if you want to configure everything yourself or via a wizard:

If you have loads and loads of free RAM, choose the wizard. If you’re running this in a VM on a laptop with 4GB with Vista as host, don’t! I’m getting the error message “There is insufficient system memory in resource pool 'internal'” after a few minutes. Luckily, there’s a link to go back to Central Admin and nothing seems to be broken. Giving my VM more memory to try this again (the link to the wizard is available in the left menu) only means my Vista is getting slower, beyond the point of dying alltogether…

So, the final step is to configure the lot yourself, but that’s out of scope for this blog. Happy installing, happy buying more RAM!

Playing around with custom fields, part 2

2009-11-15T15:25:00.001+01:00

In my previous post on this topic, I described some of the architectural choices on creating my custom field. That post was, more or less, non technical. This posting will be more code oriented.

In this second post, I’m taking you with me on my journey and the challenges underway. The third and final post will be about how I fixed it in the end.

As said before, I’ve not created a full working solution; that was not my intention and I just don’t have enough hours in a day to create one (and my wife will kill me if I try…). However, the bits below helped me gaining more insight, which was the purpose of this exercise in the first place.

The goal

Just as a reminder of what I’m trying to achieve, here’s a brief mission statement:

create a custom field that stores rating settings and displays the average rating with stars(1 to 5) in both display mode as well as list views. Store rating history and possibly user comments as well.

The result

This article is about the process of getting somewhere, namely a custom field with some specific rendering. Along the way, I’ve tried many things that didn’t do the trick so keep on reading for the lot. If you just want to hear about the result, here it is:

create a custom field that inherits from SPFieldNumber
when creating the field, in the OnAdded event create a related computed field automatically and use a specific naming convention to keep a link with the custom field
the related computed field will not store any data but is only there for rendering purposes
hide the custom field from the view and show the computed one
write some code to update the custom field data (not implemented)

Read on if you’re interested in the background information.

Creating the field type

You need to create a fldtypes*.xml file to store information on your custom field. In my case, the field is of the type “Number”. The file fldtypes_rating.xml goes into 12\TEMPLATE\XML:

     <?xml version="1.0" encoding="utf-8" ?>

    <FieldTypes>

      <FieldType>

        <Field Name="TypeName">RatingField</Field>

        <Field Name="ParentType">Number</Field>

        <Field Name="TypeDisplayName">Rating</Field>

        <Field Name="TypeShortDescription">Rating field</Field>

        <Field Name="UserCreatable">TRUE</Field>

        <Field Name="Sortable">TRUE</Field>

        <Field Name="AllowBaseTypeRendering">TRUE</Field>

        <Field Name="Filterable">TRUE</Field>

        <Field Name="FieldTypeClass">Eog.SharePoint2007.Fields.RatingField, Eog.SharePoint2007.Fields, Version=1.0.0.0, Culture=neutral, PublicKeyToken=[mytoken]</Field>

      </FieldType>

    </FieldTypes>

So far so good, this is quite easy.

Field class

It’s not only XML, it’s code as well. If your field is just an override of a standard one (but why would you do that), the code is fairly easy:

    using System;

    using System.Collections.Generic;

    using System.Linq;

    using System.Text;

    using Microsoft.SharePoint;

    using System.Xml;

    namespace Eog.SharePoint2007.Fields

    {

      class RatingField : SPFieldNumber

      {

        private SPFieldCollection _fields;

        public RatingField(SPFieldCollection fields, string fieldName)

          : base(fields, fieldName)

        {

          this._fields = null;

          this._fields = fields;

          this.DisplayFormat = SPNumberFormatTypes.NoDecimal;

        }

        public RatingField(SPFieldCollection fields, string fieldName, string displayName)

          : base(fields, fieldName, displayName)

        {

          this._fields = null;

          this._fields = fields;

          this.DisplayFormat = SPNumberFormatTypes.NoDecimal;

        }

      }

    }

Make sure to add a reference to Microsoft.SharePoint as otherwise Visual Studio won’t know what SPFieldNumber is. I’ve left out a lot of stuff in the above example but we’ll get to that later. If you want to know why there are two constructors, I strongly advise you to read the USP Journal on SPTags by Bjørn Furuknap! There’s a ton of complex stuff related to custom fields and that’s very well explained in the journal. Another good source is the great article by Wouter van Vugt on MSDN: http://msdn.microsoft.com/en-us/library/cc889345.aspx.

Strongly name your assembly, add it to the GAC and do an IISReset. That’s all there is to it for creating a simple but useless custom field. The usefull stuff is still to come.

Field control

To display a field in a custom manner, a field control would seem like a logical option. Basically, create a field that inherits from one of the base types. In the constructor, specify the field type it is related to:

    public RatingFieldControl(RatingField parentField)

    {

      this.field = parentField;

    }

In the field class, override the FieldRenderingControl method to hook up the field to the control:

    public override BaseFieldControl FieldRenderingControl

    {

     get

     {

      BaseFieldControl fieldControl = new RatingFieldControl(this);

      fieldControl.FieldName = InternalName;

      return fieldControl;

     }

    }

To render UI, either do this in code (CreateChildControls) or with a control template. If you think “hold your horses, you’re skipping all the details”, you’re absolutely right. Why? A: there’s plenty of documentation on the web via your favourite search engine. B: this approach doesn’t work for what I want!

The rendering control works fine in display and edit mode, but not in list views! List views do not load your rendering controls and only display the contents of field as it is stored. And you know what: even your Field class is not called in the list view! I’ve set a dozen break points, but none of them fires when loading the list view.

But it looks like there’s another way…

Renderpattern

The RenderPattern is a piece of CAML in your field definition (fldtypes*.xml) that provides an alternative way of rendering your field’s data. Please refer to http://msdn.microsoft.com/en-us/library/aa544291.aspx for a full reference. You use the Name attribute to set DisplayPattern, which is the pattern used in the list view. Here’s an example:

    <RenderPattern Name="DisplayPattern">

     <Switch>

      <Expr><Column/></Expr>

      <Case Value=""></Case>

      <Default>

       <Column />

      </Default>

     </Switch>

    </RenderPattern>

In this example, an expression is used to check if the column contains data. If not, it doesn’t do anything. If it does, it displays whatever specified between the <default> tags. In this case, it only renders the column value. Quite useless because not specifying this pattern will do the same, but this example is to show you the potential.

For my solution, this could work with an expression:

    <RenderPattern Name="DisplayPattern">

     <Switch>

      <Expr><Column/></Expr>

      <Case Value="">

       <HTML><![CDATA[<img src="_layouts/images/rating/rating0.gif" />]]></HTML>

      </Case>

      <Case Value="1">

       <HTML><![CDATA[<img src="_layouts/images/rating/rating1.gif" />]]></HTML>

      </Case>

      <Case Value="2">

       <HTML><![CDATA[<img src="_layouts/images/rating/rating2.gif" />]]></HTML>

      </Case>

      <Default>

       <HTML><![CDATA[<img src="_layouts/images/rating/rating0.gif" />]]></HTML>

      </Default>

     </Switch>

    </RenderPattern>

But here’s the catch: I planned to store much more than I want to show in the list view and there’s no way to filter that out with CAML. The idea was to store the rating history as well, so having the Column element in my markup would show the history as well whereas I only want to show the average. I also can’t use the column value in an expression like the one above. There’s just no way to perform advanced data manipulation before it reaches the RenderPattern.

This is becoming a challenge:

the field type does not do rendering everywher (and is not even called in the list view)

the field control is of no use in the list view as it’s not used there

the RenderPattern is not suitable for transforming my data

Trying to work around the CAML constraints

My eye felt on an attribute of the Column element: ShowField. This attribute allows you to show the contents of another field. Aha: so what if have not one but two fields; one for storing the history and one for showing the current rating?

Looks like an interesting solution, but there’s a caveat: how do I know what the related field is? If the user creates a column based on my field, it is given a name that I don’t know in advance so I can’t guess the related field name to specify in the CAML.

Related field

So what about that Column attribute hidden in the SDK: UseRelatedField? This field gets the value of a related field (quite obvious!). RelatedField is a property of SPField, giving me the opportunity to create another field via code (and thus giving me control over its name) and then connecting it to my rating field:

somehow create another field when my custom field is instantiated

relate the two by <MyCustomField>.RelatedField = <MyCustomRelatedField>

Render the value using CAML

In the RenderPattern, the related value would be retrieved like the following:

    <RenderPattern Name="DisplayPattern">

     <Switch>

      <Expr><Column UseRelatedField="TRUE"/></Expr>

      <Case Value="">

       <HTML><![CDATA[<img src="_layouts/images/rating/rating0.gif" />]]></HTML>

      </Case>

      <Case Value="1">

       <HTML><![CDATA[<img src="_layouts/images/rating/rating1.gif" />]]></HTML>

      </Case>

      <Case Value="2">

       <HTML><![CDATA[<img src="_layouts/images/rating/rating2.gif" />]]></HTML>

      </Case>

      <Default>

       <HTML><![CDATA[<img src="_layouts/images/rating/rating0.gif" />]]></HTML>

      </Default>

     </Switch>

    </RenderPattern>

Now we’re getting somehere. There are still many questions to answer:

how do I make sure the user cannot edit the related field’s value directly?

what is the best way to render my field?

how do I show the correct field in the list view?

Where are we now?

In this post, I’ve gone into some of the basics of creating a custom field as well as some of the challenges I faced with the solution I have in mind. The third and final posting will contain the final bits so stay tuned!

SharePoint 2010 BLOB storage

2009-11-05T18:06:00.001+01:00

One of the disadvantages of using a database to store large files is performance; databases commonly just aren’t designed for large files.

If you use SQL Server 2008, however, you have the option to store blobs using FILESTREAM (see http://www.microsoft.com/sqlserver/2008/en/us/wp-sql-2008-manage-unstructured.aspx or http://blogs.msdn.com/sqlrbs/).

With SharePoint 2007, you have to write your own APIs and libraries to achieve External BLOB Storage (EBS). We’ve done some implementations for customers, but it always turned out to be a hassle.

One of the key features that is promoted for SharePoint 2010, is the ability to have data storage outside the SharePoint DB build in using Remote BLOB Storage (RBS). So no need to create custom APIs and libraries anymore! Found some more details on http://sharepointsolutions.com/sharepoint-help/blog/index.php/2009/10/externalizing-blob-storage-in-sharepoint-2010/.

You can write your own providers to hook into RBS although I can’t think of any now. Perhaps write BLOBs to a Distributed File System?

SharePoint 2010 reference on MSDN

2009-10-23T23:56:00.001+02:00

Wish I’d been in Vegas at the SPC, but luckiliy, a lot of information on SharePoint 2010 is now becoming available. One good starting point is MSDN: http://msdn.microsoft.com/en-us/library/dd776256.aspx.

Happy reading!

Error when creating a SharePoint database with PSCONFIG

2009-10-22T16:23:00.001+02:00

At a customer, we’re building a dev environment where each developer has his own VM, running Windows Server 2008 (64 bit) with a domain controller (each dev machine is its own domain) , SQL Server 2005 Development edition and MOSS 2007 SP2.

We’re using scripts to automate as much of the setup as possible but run into a problem with PSConfig when creating a MOSS database. This is the command we’re running:

psconfig -cmd configdb -create -server %SQLSRV% -database %DBNameConfig% -user %ServerFarmAdminAccount% -password %ServerFarmAdminAccount_Password% -admincontentdatabase %DBNameAdminContent%

When running the script, we receive the following error:

A connection was successfully established with the server, but then an error occurred during the login process. (provider: TCP Provider, error: 0 - The specified network name is no longer available.)

In the Event Log, an event is created with ID 5586.

First, we’ve checked and double checked all variables:

user and password are OK
users are members of the appropriate domain groups
users are known in SQL and have been assigned appriopriated rights
script is run with admin priveleges
db server exsists (the database itself is created, psconfig fails on configuring it. See below for more info.)

Looking in more details at the event log, an SQL server error preceeds the SharePoint one:

EVENTID 17810: Could not connect because the maximum number of '1' dedicated administrator connections already exists. Before a new connection can be made, the existing dedicated administrator connection must be dropped, either by logging off or ending the process. [CLIENT: ::1]

As said above, the database is created but psconfig hangs on configuring it. The same script works fine in our test environment! The difference is that we’re using multiple machines and SQL Enterprise in the test farm.

We do not have any other connection to the database open when running the script so it looks like something inside psconfig.

Google doesn’t provide much help on this and none of my collegues has seen this before so if anyone knwos the key, please don’t hesitate to post a reply!

Playing around with custom fields

2009-09-22T13:08:00.001+02:00

It had been some time since I used Visual Studio so I thought it was time to play around a bit. I wanted to do something that might be of use in a customer-based scenario but not something necessarily production ready, more stuff to gain more in-depth knowledge.

This is the first of a two articles I’m going to write about this topic. In this first one, I’m focussing on the solution I have in mind and the architecture. Please mind that due to time constraints, I didn’t write a complete solution. However, that was never my goal but I found some things on my path to share with you.

The second article will be about some more technical details.

the scenario

I was triggered by a customer request for a feature to allow feedback or rating on articles written by their experts. The requirement is that on an article page, a reader can give a rating or post a comment.

I know, I know: there are solutions readily available and for a customer I would definately look at these first, but remember I’m doing this for fun…

Some existing solutions:

To keep it simple, I decided to go for a rating solution only. The basics for that solution would definately provide enough input for later enhancements.

architectural decissions

The first solution I thought of was a pretty easy one:

create a hidden list to serve as a container for the rating. This list will have the appropriate columns to store my values (user, datetime, rating etc)
create a control/web part that interacts with this list: add new ratings and retrieve existing ones. The control would use metadata values of the containing page (ID and so).
add the control/web part to the publishing page

Using a control would give me more flexibility to add it to a page layout and show it on article pages already created and as I didn’t need configuration, a control would be the right choice.

This solution would work for all cases where the content is an article page, but not for regular list items as list items do not allow a web part to be added. List items only display their fields.

Although having rating enabled on anything other than articles was not a requirement per se, I felt my solution had too many limitations. Back to the drawing board!

When the requirement is to allow rating on any type of list item, a custom field is your best choice.

The advantages of the custom field are:

it is available on the New, Display and Edit forms
its value can be displayed on the List form
it can be added to any item
it can also be added to a page
its value can be picked up by a web part on a publishing page

So what type of field do I need? Obviously, this depends on what I needed to store. I thought of two options:

store a whole lot of information with the feedback and rating, in a structured way to make sure I can apply filtering or perform calculations.
keep it simple and only store only the total rating.

Due to time constraints, I ended up with option 2, although option 1 was what I started with. Custom fields can be notoriously difficult to develop, but some excellent guidance is available. More on that in the second article, following soon.

Passed Prince 2 Foundation

2009-09-01T15:16:00.002+02:00

This morning, I passed my Prince 2 Foundation exam with a score of 79%. I've noticed many of my customers use Prince 2 so in my role between business and development, I've gained more expertise on implementing SharePoint succesfully.

background-image not set when changing a class on a DIV

2009-08-21T22:25:00.002+02:00

For I customer I was implementing a design on a SharePoint site using a custom master page and style sheet. One of my goals was to have no styles coded in the master page but to only use class references. This works very well and isn’t particularly rocket science (hey, I’ve given presentations on “dynamic HTML” when working for Microsoft in the ninties, so this should still be in my dna :-) ).

However, I ran into a nice rendering issue on a mouseover event on a div that uses a background-image set via a class (using IE8). The div is located in the QuickLaunch menu; this menu has to be collapsed by default and opened only when clicking on an arrow image:

<div id="siteContentArrow" onclick="showHideLeftNavMenuArea();" class="swSiteContentPinArrow"></div>

Clicking the div will trigger a javascript function to change the className (snippet is only part of the function):

document.getElementById("siteContentArrow").classname = “swSiteContentPinArrowDown”;

The css classes are located in a referenced stylesheet:

.swSiteContentPinArrow{background-image:url('/Style%20Library/Images/QuickLaunchPinArrow.gif');} .swSiteContentPinArrowDown{background-image:url('/Style%20Library/Images/QuickLaunchPinArrowDown.gif');}

The method above should work, but doesn’t. The className is set properly and will change basically everything but the background-image. Using a script to the set the backgroundImage property does work but means I have to put the url of the picture in my master page, something I want to avoid.

On Stackoverflow.com, I found a thread on a similar issue in IE6: http://stackoverflow.com/questions/213173/change-of-class-does-not-result-in-the-new-classs-rules-being-applied-in-ie6. Unfortunately, none of this helped me out.

The solution

Of course, if we can send rockets to Mars, fixing an anoying rendering issue should also be possible. I added a piece of javascript that loops through all rules in all stylesheets in the document and looks for my arrow classes. From these classes, I get the background-Image properties and store them in variables that are set when the script loads. The function will change the backgroundImage property using the variable values, depending on the current state of the menu:

<script>var leftNavMenuAreaDisplay = "none";var siteContentArrowBackgroundImage = "";var siteContentArrowDownBackgroundImage = "";var siteContentArrowCurrentBackgroundImage = ""; var stylesheets = document.styleSheets;        for(var i=0;i<stylesheets.length;i++){  var rules = document.styleSheets[i].rules  document.styleSheets[i].cssRules      for(var x=0;x<rules.length;x++)   {            if(rules[x].selectorText==".swSiteContentPinArrow")     {                      siteContentArrowBackgroundImage = rules[x].style.backgroundImage;           }    if(rules[x].selectorText==".swSiteContentPinArrowDown")     {                      siteContentArrowDownBackgroundImage = rules[x].style.backgroundImage;           }   }}        siteContentArrowCurrentBackgroundImage = siteContentArrowBackgroundImage; function showHideLeftNavMenuArea(){  if(leftNavMenuAreaDisplay == "none")  {    leftNavMenuAreaDisplay = "inline";    siteContentArrowClass = "swSiteContentPinArrowDown";    siteContentArrowCurrentBackgroundImage = siteContentArrowDownBackgroundImage;  }  else  {    leftNavMenuAreaDisplay = "none";    siteContentArrowClass = "swSiteContentPinArrow";    siteContentArrowCurrentBackgroundImage = siteContentArrowBackgroundImage;  }    //set style.display property to either none or inline  document.getElementById("leftNavMenuArea").style.display = leftNavMenuAreaDisplay;   //set className  document.getElementById("siteContentArrow").classname = siteContentArrowClass ;   //force render of background image  document.getElementById("siteContentArrow").style.backgroundImage = siteContentArrowCurrentBackgroundImage;}</script>

There you have it. I’ve noticed that rendering might take a wee bit of time (miliseconds…) but after the page is properly cached, no noticable delays occured. Perhaps you can use JQuery to do similar things, but this works fine for now.

e-office summer school

2009-07-09T16:14:00.002+02:00

This summer, e-office organises a summer school with a pretty exiting agenda. Topics are ranging from technology to the new way of work. Some topics are technology specific (MS, IBM, Google, Blackberry), some are multi-level ones. Please check out the web site for details. (sorry folks, Dutch only).

Content types are not document templates!

2009-05-18T21:47:00.002+02:00

Microsoft introduced content types in MOSS 2007. Content types are defined by Microsoft as follows: “A content type is a reusable collection of settings you want to apply to a certain category of content”. In practice, they consist of a collection of site columns and some other settings (like workflow).

For content types deriving from document parent types, a document template file can be attached (for example a Word document template).

This becomes visible to end users when a content type is used in a document library: under the New button, the content type appears and when clicking it, the appropriate application will open based on the defined template.

User perception

This is how most people associate the content type: something related to the application (Word, Excel etc). Seems logical because an application opens when they create a new item based on that content type. Example: we have a document content type “Project Initiation Document” that we use in a document library. A blank Word document is set as the associated template file so when a user clicks “New, Project Initiation Document”, Word opens.

In the field, I’ve noticed content types like “Word document”,
“Excel document” etc. being used solely to open the appropriate application, without any specific site column for meta information. This strengthens the user perception of “content type = template”.

Here’s the catch

Content types are great, but what if I have one called “Calculations” and sometimes use Word and sometimes Excel for its contents? The content type only allows me to associate one template file. If I have set it to use Word, I always get Word when clicking the content type from the New button. Reality is that people often use various document types to achieve similar objectives; I even made my CV in PowerPoint once.

A workaround would be to create the Excel document locally, upload it to the library and then choose the content type. However, how do you explain your average user to create some documents via the New button and some documents locally? Also, how do you make sure the locally created document is based on a template you control centrally?

This is where I think Microsoft took a wrong shortcut, connecting the content type and the document template so intimately.

How it should work

Here’s how I think it should work and should be looked at by users. A content type should be regarded as an information type, not as a document template. You should use content types to indicate that an item is of a special type, having its own set of metadata. It’s like the example I gave in the article “Using metadata instead of folders”: a car is not the same thing as a house. The document you use is only the container for the content (or the way this content is presented), the content type is the extra information you provide about that content, not about the container of that content.

IMHO, Microsoft should extend the content type mechanism so you can attach more than one template file to it. The example below is a representation of how this could work:

Before Microsoft changes any of that, please make sure you fully understand the concept of content types and that your end users do not confuse the with document templates.

Privacy gap when choosing your own manager

2009-03-30T19:34:00.001+02:00

As you’ll know, in a Mysite, a user can edit his profile data. Usually, the Manager field is synchronised with the Active Directory and cannot be filled in by the user:

Setting a manager results in an automatic display of team hierarchy in a treeview consisting of users who share the same manager:

The audience who can see details, can be set on some fields the user can fill in:

My Manager is set by the manager field, My Collegues and My Workgroup are somewhat special. You can add people to your My Collegues group and mark them as member of My Workgroup:

If someone shares the same manager as you, that person will be automatically added to your My Collegues group and markes as My Workgroup as well.

So here’s a catch: if you allow people to set their own manager, they will be automatically added to your My Collegues and My Workgroup!

I’ve tried this on my VM:

in the SSP, Profile settings, change the manager field to be updatable by users
create 3 user accounts, give them access to SharePoint and allow them to create a Mysite.
log in to Windows with user 1 and create a MySite. This user will be the manager.
now log in to Windows with user 2 and create a MySite. Set user 1 to be the manager. Note: signing in in SharePoint with the user account is not enough as you’ll be redirected to the Mysite of the windows account. Verify the Collegues page.
now log in to Windows with user 3 and create a MySite. Set user 1 to be the manager.
Now log in to Windows with user 2 again and go to the Mysite. Check the collegues page to verify that user 3 has now been added to My Collegues and My Workgroup without ever asking for permission.

The impact on security is open to discussion as only some personal details can now be seen by people you didn’t have in mind. Security on list items is not breached as that is set on groups or individual users, not on social distance. However, it’s worth reconsidering whether to allow end users to fill in their own manager.

Using metadata instead of folders

2009-02-23T14:34:00.001+01:00

Although a great deal of information is (and opinions are) available on the web, most of them favouring the use of metadata instead of folders, I'd like to add some samples that I use in my daily work. I often use these samples at companies that are "migrating" their file shares to SharePoint (2007 version). Please notice the quotes, intentionally put there to stress that using SharePoint instead of file shares is much more than just a migration: it's a whole new way of work! However, that's a bit out of scope for this article so let's stick to metadata versus folders.

We love to structure our data...

... and that's actually not a bad habit. A common scenario at customers is a file share for project teams that structure their data based on some properties of their projects, like the following example:

Division a
- Department b
  - Project c
    - Stage d
      - Document 1
      - Document 2

People have worked like this for ages and seem generally satisfied with this solution.

Not so structured after all?

The sample above can work as long as:

there is good governance on the structure
there are not too many levels
you do not have to share document across projects

There might be more properties available than can be used without creating a ridiculously complex folder structure:

author of the document
create date of the document
customer
version of the document
project year
etc.

Often, extra data is stored in the title of the document, like "pid draft version 0.5 - modified by John - to review.doc". From the title, you can get extra information: it's a Project Initiation Document (pid), it's not final, it's been modified by John and should be reviewed. What if it had not been called pid but "prj. in. doc.doc"? It's still a pid, but would you immediately recognise it as such?

Creating duplicates

Using folders for structuring files might work when these files stay within that one folder. However, some files belong to more than one folder. In the folder structure above, 'Document 1' might also belong to 'Project f'. The general solution is creating a copy of the document, causing the following major problems:

not clear which version is the latest and greatest
not clear who is the document owner
need for extra storage

The route to finding information: vertical/horizontal navigation

A folder view is a vertical way of finding information: you'll find the document via a vertical path that someone else has defined. That path might not be the one you want to follow. A great example is a second hand car site. On that site, there are thousands of cars available and you are looking for that one car. Suppose the site had been structured with a folder view, like:

brand (e.g Mercedes)
- model (e.g 320)
  - fuel type (e.g. Petrol)
    - colour (e.g. Silver Metallic)
      - milage (e.g. 70k-80k)

That would work if you'd been looking for a Merc. But what if you're looking for a car with the following criteria:

not more than 5 years old
petrol
mileage between 50k-80k
hatchback
price between €20k-€35k

The folder view above won't work for you as you'll have to browse each (sub) folder to find cars that match some (but not all ) of your criteria. You don't want a vertical view, you want a horizontal one!

To map this to information within your organisation: you might be able to find the information you're working with because you know the folder structure, but what about all the other employees that might be looking for that information? What about the manager looking for the latest project status reports for all projects?

Did I mention metadata?

We use metadata more often than we think. As Wikipedia describes it: Metadata (meta data, or sometimes metainformation) is "data about other data". In the car example above, the properties of the car are its metadata: information about the car. So if you're looking for a car (age, mileage, etc), a partner (gender, hobbies, etc) or house (type, price, etc), you use metadata to filter. As you can see, each type of object I'm looking for (car, partner, house, etc) will have its own metadata; it wouldn't make much sense to filter on fuel type for a house...

The folder view allows you to add metainformation implicitly, i.e. the location where the item is stored defines its metadata. Once the item is moved to another location, it looses that meta information. Using metadata on the item itself, means that metadata becomes explicit. No matter where you store the item, it keeps its metadata. There are some technical requirements to achieve this, but that will be explained next.

Metadata with SharePoint

Although it's possible to create folders in SharePoint document libraries, I generally do not recommend it: see the sections above. SharePoint implements metadata as columns. End users sometimes find it hard to grasp this concept, but the I use the example of Excel. Almost everyone in an organisation has used Excel so a spreadsheet like the following should look familiar:

Most people also know you can apply filtering in Excel:

And that's also how SharePoint works! (plus more)

SharePoint stores items in lists/libraries and uses columns to provide extra information about the items. SharePoint even allows you to store different types of items (remember the car, partner and house) in one list using so-called content types.

Using metadata, users can now apply filtering, sorting and grouping on the data, either directly or with views.

flat view:
grouped view:

Retaining metadata when moving items around

I've already mentioned that SharePoint has ways to keep the metadata with the item. Using Content Types is a great way of applying the same metadata structure to lists and libraries. When the item moves to another list that has the same columns, it will keep its metadata. Office files have an even better mechanism build in as metadata is contained within the document itself! Try it out yourself by adding metadata to, for example, a Word document in a library. Now copy the file to another library that does not have the same metadata columns yet. Once you have added the same metadata columns (use the same internal name for the columns!), they will automatically show the metadata. Beyond cool!

Conclusion

Metadata in SharePoint allows you for a much more flexible way of structuring your data than using folders on a file share. When you want to implement SharePoint, leave the folder way of thinking behind and start thinking in more dimensions!

Publishing versus collaboration

2008-11-18T20:49:00.001+01:00

It has been a while since my last post, so it's time to post once again. This time, it's not something technical. It's related to something me and my collegues at e-office often notice @ customers who are implementing SharePoint.

Solution to what?

What are customers trying to solve by implementing SharePoint? The answers are as divers as hard to get. In many cases, SharePoint is put forward by an IT department as the product to use. If it delivers what the business needs is not clear, but there is confidence that SharePoint can meet any need.

OK, I'm a SharePoint addict and I'm confident you can do a lot with it, OOTB or custom made, but listening to the business is a must do as SharePoint is meant to solve business challenges, not IT challenges (in fact, SharePoint can add a few to those IT challenges...).

Commonly, when you get the answers, SharePoint will be used in an organisation for two types of solutions:

As a publishing intranet (MOSS), and/or
As a collaboration environment (WSS)

I know there are many more uses, but for the sake of this post, I'll leave it at these two.

The intranet

MOSS is great for it's OOTB publishing templates: in no time, a complete company intranet can be set up. An intranet has some characteristics:

it serves as an information channel: its contents are relevant to a broad audience
it is accessed by many who read, by few who contribute
its consists mainly of published content (drafts are not visible to the general public)
the type of content is mainly pages
its contents is often part of an approval cycle
its content is often the output of some sort of process, not part of the process itself (like supporting documents)
its content is highly structured
style and layout are usually more corporate branded

In short: it's one way traffic on the information highway. There are more characteristics, but the list above is sufficient for the purpose of this post.

The collaboration environment

WSS is great for having team members working together in a virtual environment. This environment has some characteristics:

it contains content that is only relevant to members of the team
its content is mainly part of a process, not primarily the final output of this process (example: a team site might be set up for creating a HR reference document which is then published on an intranet)
the type of content is mainly documents
there are many contributors, only a few readers
work in progress (draft) is visible to all members
its content is free form
style and layout are functional

There are more characteristics, but the list above is sufficient for the purpose of this post.

Can we do it in the mix?

There's not a problem that we can't fix... (pun intended) but mixing WSS and MOSS can lead to problems that are hard to fix indeed. These are not of the technical kind, but functional. Above, you've seen that MOSS and WSS can be used to achieve great intranets (MOSS) and great collaboration environments (WSS). But when you install MOSS, you have WSS as well and can be tempted to use publishing sites with collaboration elements. Quite often, I meet customers who have implemented MOSS and created an intranet with sites/pages that combine the publishing and collaboration features on a functional level. This results in, for example, department sites that show:

information about the department ("who are we? What do we do?")
information for the people within the department (like announcements)
documents that are part of processes within the department (like draft status handbooks)

The result is a site or page that is only partially interesting for whoever looks at it:

if you're in that department, you know "who you are" and "what you do"
if you're not in the department, you are not interested at all in the drafts

Furthermore, because now collaboration and publishing data are mixed, it's virtually impossible to achieve some sort of uniformity or to control what is shown. Also, this can only work when the site map of the intranet reflects the organisational structure. When you have inter-departemental collaboration, you can't reflect that in an intranet where the structure is department oriented. It's quite difficult to publish information on several places (for example: content can be related to a department but also to a theme. Both department and theme have sites/pages in the intranet). Furthermore, what happens if the team moves from one department to another?

Technically, you can work with permissions and audiences to limit what is shown. With metadata and the content by query webpart, you can show information from one area on another. However, this doesn't take away the fact that mixing publishing and collaboration is fundamentally wrong: they are different concepts!

Guidelines and solutions

Here are some guidelines and solutions I usually advise:

use publishing sites for publishing only
use team sites for collaboration
place your collaboration sites either under the sitesdirectory as subsites (easier for central metadata management) or create new site collections (under the managed path "sites"). This makes it much easier to control access. If you expect many sites of a kind, consider using a different web applicayion for collaboration and publishing.
use metadata and/or workflows/SendTo to show final output created at collaboration site level on the publishing site(s)
make a visual difference between the collaboration and publishing environment. This makes it easier for the users to see where they are. For a collaboration environment, keep it functional.
before you start developing, make sure the customer understands the concepts and has defined the business requirements
provide training for the people who work with it

Never say never

So should you never use publishing features in a collaboration environment? Well, that's not my message. You can use whatever template meets your requirements. If you need to have, for example, news pages within a collaboration environment, why not use a template that enables them. My message is that on the functional level (or better: the content level), you should separate collaboration and publishing. Put some time in the business and functional requirements and then decide how to structure your SharePoint environment and what templates should be used where.

passed 70-631

2008-10-22T22:35:00.002+02:00

I'm ashamed that this is the first posting since May, but I've been too busy working on challenging MOSS projects. Anyway, I passed the 70-631 exam with a score of 945. Must have gotten my name wrong...