Maxime Bombardier - SharePoint Architecture & Development

Upgrading your enterprise to Office clients to 2010 – performance incentives

MaximeB — Fri, 30 Oct 2009 03:11:00 GMT

The last couple years have been very interesting from a collaboration, social, IT, and end-user productivity perspectives. We have a seen a tremendous growth of unstructured documentation – or the recognition of it – which leads to companies to want more efficient collaboration tools.

The so called shift of generations, events like the economy breakdown and the H1N1 flu all makes good cases for better end-users efficiency. For example, we are seeing bigger recognition that instant messaging, voice over IP, video conferencing, and remote work are becoming essential work tools – it’s not just your family friendly Geocities (/wink), My Space, Facebook, or Twitter.

With that came along the Office 2007 suites for both client and server. On the client side, we introduced the Fluent interface (or Ribbon bar) which was a shock for a lot – but a welcome one. Try to make Pivot charts with 2003 to see what difference the 2007 ribbon (and more) brings. And we all know about SharePoint 2007’s successes.

But did large enterprise move to the 2007 Office client? Of course some or lots did – but I still have a lot of customers with 2002 or 2003 (or sometimes worst…). Those enterprise are usually geographically dispersed and their deployment tools are usually too complex for practical use. They were used to deploy new Office with new Windows. Did these enterprise move to Windows Vista? Those deployments are often IT driven that try to get a business buy-in.

What this created is a gap. A lot of their employees bought new laptops or even Netbooks. They’ve had Windows Vista or XP on the Netbooks – but they also had Office 2007 at home. They love the 2007 interface and have started making noise at work so that they understand why they can’t have the new version.

This gap is creating a shift where the end-users are demanding IT to deploy Office 2007 – and massively. Now bringing this discussion back to SharePoint, I find that a simple yet very important factor for IT to consider – especially for those branch deployments – is the 2007 file format. Everything is compressed now. Those large files that are now being pulled more & more in the centralized (or sometimes dispersed) SharePoint through collaboration & search could be automatically smaller by size and save precious network bandwidth.

This is today. Tomorrow brings 2010 and even more performance benefits from an Office client perspective.

First of all, Office 2010 supports the Cobalt protocol. The Cobalt protocol is what we built for Office Online so that users only send the compressed differentiation, or delta, of the file. This means that a user opening a 5 MB Word file and apply updates totalling 150 KB, only those 150 KB or less – since it will compress it – will be sent back to the server.

Cobalt also allows for multi-user editing. For the Office client, it allows co-authoring for Word and PowerPoint. For the SharePoint Office Web Application, it allows for Excel and OneNote co-authoring. The co-authoring of Excel in SharePoint is very slick, each user see the all changes almost automatically. The versioning and presence integration is also very well done with this co-authoring.

Second, there is a new component called the Upload Center that allows the user to save his change and close Word right away. Word will update the server asynchronously in the background instead of blocking the user. This allows for a user perspective performance gain – especially on low latency / low bandwidth environments.

3rd, there is the Offline Document cache (which works with the Upload center) that supports Word, Excel, PowerPoint, Visio, SharePoint, and Groove. Note that OneNote is already cached differently.

3rd, the Office Web Applications allows for users to view Word, Excel, PowerPoint, and OneNote documents without a client – and only send the updates with Cobalt again.

Last, the SharePoint Workspaces (formerly Groove) is more complete and allows for a very good offline experience for remote users.

Note that there are also tools such as NXPowerLite that optimize files – for example, when you cut & paste a Visio diagram in Word, it looks nice but it’s also very big – NXPowerLite ‘takes a picture’ of that object and inserts the picture instead. I’ve a had a case of a Word document at over 10 MB with Visio objects in it – and it reduced to less than 750KB when I switched the objects to pictures.

As you can see, Office 2010 will bring very good performance incentive that both IT and end-users will want. And of course, it brings so much more too :) And let’s face it, you’ll want Windows 7 too! With the large audience with the beta/pre-release versions, companies need not wait for a service pack to plan installing Office 2010.

Maxime

Little Central Administration Security Bug with SharePoint 2010

MaximeB — Wed, 28 Oct 2009 19:58:07 GMT

I ran into a little frustrating issue earlier with my Stand Alone installation on Windows 7 – my account had access to the Central Administration but some options weren’t there (like manage services on server) and others were giving me Access Denied. The ‘New Web Application’ was grayed out with a text saying I didn’t have access when I did a mouse over.

I was correctly set up as a farm administration and site collection administrator for the Central Admin. I tried rebooting and using other local accounts instead of the domain account – no luck.

So I started up the wizard with the intention of scrapping my newly built farm and simply re-create it but the wizard simply just ran over without asking me to remove it! The nice thing is that the automatic repair actually repaired my issue as well :)

Quick fix!

October 29th Update: Actually, it looks like I was wrong. The issue came back the next day and the Wizard didn’t fix it – nor did I want to run the Wizard everyday ;). As it turns out, you need to ‘Run as Administrator’ Internet Explorer … what baffles me is that it sometimes work, sometimes not (and I had never ran IE as administrator… nor did I remove UAC on my Windows 7 build).

Maxime

Installing SharePoint 2010 on Windows 7

MaximeB — Wed, 28 Oct 2009 17:05:44 GMT

I had a mission this week where I wanted to find out how to install SharePoint 2010 on Windows 7. I’m currently attending the SharePoint Ignite for Implementers – however, this subject isn’t covered in the sessions so I wanted to test it out at the same time while I have other tech guys around.

Actually, to my great surprise, we actually have a great MSDN article already available on this: http://msdn.microsoft.com/en-us/library/ee554869(office.14).aspx. This article does explain most of the requirements ** READ IT COMPLETELY BEFORE ATTEMPTING **.

Obviously, I didn’t :). Who does Stand-Alone installation nowadays, right?

So I went ahead and install my SQL Server 2008 SP1 and did a server install. And then, in the wizard, I had a choice of an unmanaged error if I was using a domain account (for SharePoint), or a managed error saying that I can only have a Stand Alone installation if I want to use local accounts (which I wanted to – I wasn’t about to use a Microsoft Domain account for my test box).

Anyhow, I had to uninstall SharePoint, Office Web Applications, and the language pack, some registry keys, and I could try again.

The other thing is that the MSDN article mentions something about extracting the setup file – mine were already setup but that could be my build. What I had to do was to check in the “.\Files\Setup” sub-folder and open up the setup.config file. As described in the article, you have to add the following line:

I also installed all the pre-requisites – except PowerShell V2 CTP3 which is already on Windows 7. You can get the list of pre-requisites here: http://blogs.msdn.com/opal/archive/2009/10/25/sharepoint-2010-pre-requisites-download-links.aspx

When you start the install, you’ll get the ‘non-supported for production’ notice:

The rest is standard and it actually runs fine!!

I’ll be playing with my new Windows 7 SharePoint 2010 installation in the coming days – if it means I don’t have to reboot to a VHD or launch an Hyper-V, that’s great news for me.

Update: I ran this on 4514.1009 with an English installation of SharePoint Server + French Language Pack + the Office Web Application Server.

Update: I’m not sure if it’s a requirement when installing on Windows 7 – I know it is for Windows 2008 R2 – but I did install it and I think it’s required : the kb971831. Unfortunately, the fix isn’t available for all versions publicly. Chances are, if you have access to the 4514.1009 build, you have access to the fix too. I’ll update when I’ll know about the public Beta 2.

Another update! I tested out the computer going to sleep and it works great. Within 15 seconds of opening up the lid, I had the Central Admin & Portal opened up from a new IE instance and it was fast to load it up – the .NET assemblies were still in cache.

October 29th Update: To be safe in Central Administration, you’ll need to run as Administrator … what’s odd is that it’s somewhat random for me. Everything is fine except in the Central Admin. My symptoms when I don’t have access: I do not see the Services on server link in the CA, I can’t create Web Applications, I can’t manage Metadata, etc. You can disable UAC as well if you want – I’m simply running the default parameters in Windows 7.

I’ll let you know how that goes. Next step, Visual Studio 2010 Beta 2 and test development – that’s what it’s for after all.

Maxime

Error in PortalCrawl Web Service when crawling people with SharePoint 2010

MaximeB — Tue, 27 Oct 2009 21:06:30 GMT

I was playing with User Profiles and Search with SharePoint 2010 and I was getting some odd results. First of all, I would get results from the user’s ‘my sites’, but not actual ‘people’. By looking at the scopes, I could see that no results were available for the People scope.

So I checked up my crawl log and sure enough, I had a single error: Error in PortalCrawl Web Service. Now that doesn’t really tell me anything so I checked out the logs and found the following 2 related messages:

10/27/2009 14:18:52.15 w3wp.exe (0x1540) 0x18C8 Office Search Server Common 7ps2 Medium PortalCrawl.GetSite(): System.UnauthorizedAccessException: Attempted to perform an unauthorized operation. at Microsoft.Office.Server.Administration.UserProfileApplicationProxy.DemandAdministrationAccess(UserProfileApplicationAdminRights rights) at Microsoft.SharePoint.Portal.Search.PortalCrawl.PortalCrawl.GetSite(_PortalSite& sSite). 88e720df-4686-4aa5-bf8a-197ae1900bfb

10/27/2009 14:18:52.16 mssearch.exe (0x0738) 0x1FF0 Office Search Server Gatherer cd11 Warning The start address sps3://my cannot be crawled. Context: Application 'Search_Service_Application', Catalog 'Portal_Content' Details: Error in PortalCrawl Web Service. (0x80042617)

Now I could tell I had an access error so I validated my DisableLoopbackCheck registry key – it was already set; checked the web application user policies (which is now in the Central Admin > Security > Specify web application user policy), the search account already had its permissions; I even checked the http://my web site and the account also had permissions there.

When looking back at the error message – and more precisely the stack trace – I could see the class for UserProfileApplicationProxy – I hadn’t checked my proxy permission.

If you look at those permissions, there’s an explicit ‘Retrieve People Data for Search Crawlers’ checkbox.

Now, if you run the wizard to create your service applications, it will use the default account (which probably has too much rights) and give the right permissions. When you go and change the ‘default content access account’, it will not give that permission – only the web application user policy ‘Full read’ permission.

Not sure if this behaviour will change for RTM or not so make sure you check the permissions for the content access account in the proxy ‘administrators’.

Maxime

Missed out on SharePoint Conference? SharePoint will be at the PDC!

MaximeB — Tue, 27 Oct 2009 18:34:52 GMT

For those who missed out on the SharePoint Conference and are still looking to view SharePoint 2010 goodies, there will be a good portion of the PDC that will be focused on SharePoint.

Steve Fox has a good post on this here.

Unfortunately, I will not be able to attend the PDC this year but I’m very happy to see more SharePoint coming in that conference – I’m particularly interested in the Silverlight to SharePoint portion – there’s a whole client API for it now! That should be very interesting for Intranet scenarios…

You can check out all of the sessions at PDC here: http://microsoftpdc.com/Sessions.

You can check out all of the keynotes for PDC here: http://microsoftpdc.com/. (Click Keynotes.)

And most importantly, you can register here: http://microsoftpdc.com/Registration. There’s a discount in effect until the end of October, so register today!

One or more types failed to load error when using the SharePoint 2007 Wizard

MaximeB — Fri, 02 Oct 2009 05:05:11 GMT

I have been playing much with 2010 (client and server) lately so it brought me a new problem with 2007!

If you have the Office 2010 CTP client installed and you try to run the SharePoint 2007 Wizard, it will fail quickly on step 2 with the error "One or more types failed to load”. Unfortunately, the only fix is to remove the Office 2010 client.

You can keep Project, Visio, and SharePoint Designer 2010 (which are different installs). You can reinstall the client after – until you need to re-run the wizard.

Maxime

BlobCache, Style Library, and anonymous users

MaximeB — Tue, 11 Aug 2009 14:36:24 GMT

As a follow-up to Chris O’Brien’s posts regarding BlobCache and 304s, which can be found here and here, I wanted to clarify the situation as to when you may have 304s.

By default, the Style Library (and Master Pages gallery for that matter) is breaking permission inheritance. However, during its creation, the SPList.AllowEveryoneViewItems property is set to true – thus giving anonymous users access – remember, the list is created before anonymous access is given, this property thus simplifies giving access to everyone during creation.

If you enable anonymous access (i.e.: Entire Web Site) on the root permission, and you access the site anonymously, you will not be prompted for credentials. However, when the BlobCache goes through the list’s permissions, it doesn’t find anonymous access and will not serve the request.

As a result, while the file is saved in the BlobCache directory but not served to the user from that cache, the cache-control Http Header will still contain “private, max-age=0”. At the next user request, the browser will validate its cache against the file on the server and return a 304.

Workaround

The workaround is simple, the first step is to explicitly give anonymous access to the Style Library – either by resetting to inherit from parent or by giving anonymous access. The 2nd step is to clear the BlobCache on all zones and all servers.

The ‘Clear BlobCache’ checkbox in the ‘Object Cache’ page will only clear it for that zone for that server – you should clear it either through the web application property. Changing the BlobCache directory (in the web.config of all servers for all zones) the BlobCache will also work.

While Chris’ last post regarding this did essentially provide the workaround, there was some confusion due to the nature of the tests (which can bring false positive or false negative results if you don’t follow steps rigorously), and the cache clearing that may be inaccurate if you do it on the wrong zone/server.

Final note

If your WCM portal use files from the Style Library (or any other list you created and set the AllowEveryoneViewItems property) and allows anonymous access, make sure you update the list’s permission and clear the BlobCache on all zones/servers. This will allow user to cache the files and reduce the server impact (i.e.: the 304s) considerably. This should be part of your “provide anonymous access” procedure.

A correctly configured BlobCache is essential to a high performing web site.

Variation Strategy #2 to remove label overwrites – cancel updates!

MaximeB — Sat, 01 Aug 2009 19:45:04 GMT

In this first Variation Strategy post, the solution was not the most elegant but the only out of the box one.

The main problem I’m facing with customers is that they simply want variations on ItemCreated only. They do not care about updates done in the original language as to their impact to the other languages. Worst, the mechanism today not only overwrites a target page from the source (which is in another language), but you cannot simply go back to the original target page in the right language – you have to reapprove it!

Unfortunately, as far as I have been able to discuss with the product group, this behaviour isn’t changing at this moment. By looking at the events fired up for the current Variation mechanism, I can see why as there are tons of use cases.

So the first post is really what I recommend customer going for as it stays OOB only and doesn’t affect the product. This 2nd post will detail a 2nd solution that plays with the product but doesn’t affect its underlying core.

Let’s quickly go through how variations works :

You define a source variation
You can choose to have manual creation propagation or automatic for either site or site+pages
1. What this means is that once a page is propagated, it is linked and any published updates to the source will kick in the variation propagation again.
Every time a page is approved in a source variation, it will log the event in a list
Once every minute, there is a timer job that reads the list and propagate any required sites and pages
1. If a target page exists but isn’t linked, an error will be raised
2. If a target page is linked but checked-out, a force check-in will occur and it will then update the page with the content from the source
3. If a target page doesn’t exist, it will create it and add an entry in the Variation Relationship list.

As for the process for when a page get updated:

You have a source page, published as version 1.0, with page content “EN”
You have a target and linked page, published as version 1.0 as well, but with page content “FR”
You update the source to “EN – 2” and publish it as version 2.0
After the Timer Job passes, the linked target page will have page content “EN – 2” as version 1.1.
1. Visitors will still see “FR” from version 1.0
2. Content managers will however see “EN – 2”
3. There is no rollback, you have to check-out the page, retrieve the previous published version, and re-publish (or re-approve) it!.

This last portion is what customers do not like in general. They’d like to have the ability to have the relationship list but not the items to be updated in target labels every time. While it may make sense in some content update cases, there’s often little changes in a page that doesn’t need to be replicated to all labels.

Solutions to block updates?

So if you ask yourself what you can do, you will end up with 2 possible solutions:

Can we intercept the update and cancel it if the update comes from the source?
Can we manage a relationship list on our own based on ItemCreated only?

Solution #1 wasn’t a definite until I looked at it – and I’ll come back to it as this is the reason for this post; Solution #2 is appealing but isn’t that easy. Maintaining a relationship list means:

Creating your own Language Picker control (granted, you should anyway as the out of the box one will give you the link even if the page hasn’t been published yet)
Create your own Labels screen which will allow pre-creation of label and post-creation of label
Create your own Event Receiver for ItemAdded that will kick in only for your source variation. This will create the same page on a target label but it will not have content since we do not have it on ItemAdded – we’d have to hook on ItemUpdating/ed to do this but this is the point, we do not want to.
Create your own Event Receiver for WebDeleting to manage the relationship list
The Relationship List will contain IDs for sites and pages so that your language picker control can provide the link to the right page.
You may want to have an Update Variation link to force a push down of content, a variation log view, etc.

And I might be forgetting some things – but worst, if the product changes, you aren’t using the real variations. It does offer some advantages and I’ll probably try this solution in the future – but this would be a last resort.

Can we intercept the update and cancel if the updates comes from the source?

Let’s go back to Solution #1. The answer is yes but it wasn’t that easy to catch all (hopefully all…) use case. First of all, there was 2 way :

You could check who is doing the update. If it is the system, it *could* be the variation mechanism – however, it could be the approval workflow as well so this isn’t good
You can add a Publishing Field (like HTML) to all pages and manage its content. It will contain a different value at the source than the targets.

So the solution breaks down into these blocks:

A Site Collection Feature that, on activation, adds the Publishing Html Site Column and adds it to the Page content type. It will also loop through all webs and activate the Web Feature.
- On deactivation, it will remove the column from all Pages list in all webs, remove the column in the site content type, and delete the site column. It will also loop through all webs to deactivate the web feature.
A Web Feature that, on activation, add 3 event receivers for ItemAdding, ItemUpdating, and ItemUpdated.
- On deactivation, it will remove the events on the Pages list
An Event Receiver class that will intercept the 3 events
- On ItemAdding, we will set the value of the field to either “source” or “target”
- On ItemUpdating, we will validate if the AfterProperties are set to “source” while the ListItem contains “target”
  - If so, we cancel the update
- On ItemUpdated, we will force to set the value if it didn’t kick in previously.
  - Note: I did this one because of some rare case where you activate/deactivate/reactivate features – you will have pages that may have been created without going through ItemAdded – the value isn’t right.
A Feature that staples the other Features to your Site Definitions so that when you create your sub-sites, it will activate the Web feature automatically.

There are also various use cases to keep in mind:

Ability to stop or start this feature at any time (i.e.: if the product changes in the future, you will want to stop this package without any impact) -- this means that a page may not contain the ‘VariationStatus’ value, or a target may contain ‘source’ if you had the the feature running at one point, stopped it, and updated the source.
Support for updating the target page (obvious, but it’s the same event)
Support for when you have or don’t have versioning
Support for Content Deployment
Ability to work on an existing site
Support over the current variations without error messages

What will not work:

Any updates from Variations after the first one will not go through (well, that’s the point). This means that if an editor uses the “update variations”, it will say it worked but no updates will have gone through
I think I have a case where, after updating the source page, if you click “modify”, it will say you need a refresh first. I’ll have to look again into this one – it may be fixed now as I used SPListItem.SystemUpdate(false) at one point in ItemAdding.

The reason for this, and it’s also why this solution works, is that there are 2 ItemUpdating events. The first one contains the updated fields – you want to cancel it; the 2nd contains what I assume is necessary for the variation to work (the relationship, the logs, etc.) – you let that one go through.

The bulk of the solution lies in having a Publishing Field – which is the only thing brought at every updates from the Variation propagation job – that contains a different value at the source than target.

Note: All tests were made with an English Site Collection – I’ll have to test when it’s not the case as the Variation Labels list may have a different name.

Code - Constants

        1: using System;

       2: using System.Collections.Generic;

       3: using System.Linq;

       4: using System.Text;

       5:  

       6: namespace MB.SharePoint.ApplicationLogic

       7: {

       8:     public static class Consts

       9:     {

        public static class Guids

        {

            public const string contentTypePage = "0x010100C568DB52D9D0A14D9B2FDCC96666E9F2007948130EC3DB064584E219954237AF39";

  

            public const string VariationOnCreateOnlySite = "{3389D85A-4122-4fb3-B46E-C6A3B404F2C1}";

            public const string VariationOnCreateOnlyWeb = "{CFF1173C-688D-4e43-9878-F660803625DC}";

        }

  

  

        public static class Fields

        {

            public const string GroupName = "MB";

            public const string variationOnCreateOnly = "MBVariationStatus";

        }

  

        public static class FieldTypeNames

        {

            public const string RichHtml = "HTML";

        }

  

        public static class Values

        {

            public const string variationOnCreateOnlySourceValue = "source";

            public const string variationOnCreateOnlyDestinationValue = "target";

  

  

        }

  

    }

}

Code – Utility methods

       1: using System;

       2: using Microsoft.SharePoint;

       3: using Microsoft.SharePoint.Publishing;

       4:  

       5: namespace MB.SharePoint.ApplicationLogic

       6: {

       7:     public class Utils

       8:     {

       9:         private static object _lock = new object();

        private static string sourceVariationUrl = "";

  

  

  

        #region Columns and Content Types

        public static void AddSiteColumn(SPSite site, string fieldTypeName, string fieldName, bool hidden, bool required, string description, string group, string defaultValue)

        {

            SPWeb web = site.RootWeb;

  

            if (!web.Fields.ContainsField(fieldName))

            {

                //add the field if it doesn't exists

                SPField newField = web.Fields.CreateNewField(fieldTypeName, fieldName) as SPField;

                newField.Hidden = hidden;

                newField.Required = required;

                newField.Description = description;

                newField.Group = group;

                if (newField != null)

                    newField.DefaultValue = defaultValue;

                web.Fields.Add(newField);

                web.Update();

            }

        }

  

  

        public static void AddSiteColumnToContentType(SPSite site, SPContentTypeId contentTypeID, string fieldTypeName, string fieldName, bool hidden, bool required, string description, string group, string defaultValue)

        {

            SPWeb web = site.RootWeb;

            SPContentType contentType = web.ContentTypes[contentTypeID];

  

            if (contentType != null)

            {

                AddSiteColumn(site, fieldTypeName, fieldName, hidden, required, description, group, defaultValue);

  

                if (contentType.FieldLinks[fieldName] == null)

                {

                    //link the field to the content type

                    contentType.FieldLinks.Add(new SPFieldLink(web.Fields[fieldName]));

                    contentType.Update(true, false);

                }

            }

  

        }

  

        #endregion

  

  

  

        #region Publishing

        public static bool isSourceVariation(string url, SPWeb web)

        {

            string sourceUrl = sourceVariationUrl;

            if (sourceUrl == null || sourceUrl.Length == 0)

            {

                lock (_lock)

                {

                    sourceUrl = sourceVariationUrl;

                    if (sourceUrl == null || sourceUrl.Length == 0)

                    {

                        //Get Source variation from list -- we cannot use API since we do not have a context

                        using (SPWeb rootWeb = web.Site.RootWeb)

                        {

                            try

                            {

                                //get labels

                                SPList labelsList = rootWeb.GetList("/variation labels");

                                SPQuery query = new SPQuery();

  

                                query.Query = "<Where><Eq><FieldRef Name='Is_x0020_Source'/><Value Type='Boolean'>1</Value></Eq></Where>";

                                SPListItemCollection labels = labelsList.GetItems(query);

                                foreach (SPListItem item in labels)

                                {

                                    sourceUrl = rootWeb.ServerRelativeUrl.ToUpper() + ((string)item["Title"]).ToUpper();

                                    sourceVariationUrl = sourceUrl;

                                    break;

                                }

                            }

                            catch (Exception)

                            {

                                //problem reading variation list, return false by default

                                return false;

                            }

                        }

                    }

                }

            }

  

            return url.ToUpper().StartsWith(sourceUrl);

        }

  

  

        public static void DeleteFieldFromAllPagesLists(SPWeb web, string fieldName)

        {

            if (PublishingWeb.IsPublishingWeb(web))

            {

                PublishingWeb pubWeb = PublishingWeb.GetPublishingWeb(web);

                SPList pages = pubWeb.PagesList;

                if (pages.Fields.ContainsField(Consts.Fields.variationOnCreateOnly))

                {

                    pages.Fields.Delete(Consts.Fields.variationOnCreateOnly);

                    pages.Update();

                }

  

                pubWeb.Close();

            }

  

  

            if (web.Webs != null)

            {

                foreach (SPWeb subWeb in web.Webs)

                {

                    DeleteFieldFromAllPagesLists(subWeb, fieldName);

                    subWeb.Dispose();

                }

            }

        }

  

        #endregion

  

  

  

        #region EventReceivers

        public static void AddEventReceiver(SPList list, string className, string assemblyName, SPEventReceiverType type, int sequenceNumber)

        {

  

            bool isNewEvent = true;

            foreach (SPEventReceiverDefinition eventReceiver in list.EventReceivers)

            {

                if (eventReceiver.Class.ToUpper().Equals(className) && eventReceiver.Type == type)

                {

                    isNewEvent = false;

                    break;

                }

            }

  

  

            //Add Event Receiver

            if (isNewEvent)

            {

                SPEventReceiverDefinition eventReceiver = list.EventReceivers.Add();

                eventReceiver.Type = type;

                eventReceiver.Assembly = assemblyName;

                eventReceiver.Class = className;

                eventReceiver.SequenceNumber = sequenceNumber;

                eventReceiver.Update();

            }

        }

  

        public static void DeleteEventReceiver(SPList list, string className, SPEventReceiverType type)

        {

            foreach (SPEventReceiverDefinition eventReceiver in list.EventReceivers)

            {

                if (eventReceiver.Class.ToUpper().Equals(className.ToUpper()) && eventReceiver.Type == type)

                {

                    eventReceiver.Delete();

                    break;

                }

            }

        }

  

        public static bool IsItemUpdatingFromCheckin(SPItemEventProperties properties)

        {

            return (properties.AfterProperties["vti_sourcecontrolcheckedoutby"] == null && properties.BeforeProperties["vti_sourcecontrolcheckedoutby"] != null);

        }

        #endregion

  

  

  

        #region Features

        public static void ActivateFeatureRecursively(SPWeb web, Guid featureId, bool force, bool checkForPublishing)

        {

            if ((checkForPublishing && PublishingWeb.IsPublishingWeb(web)) || !checkForPublishing)

                web.Features.Add(featureId, force);

  

            foreach (SPWeb subWeb in web.Webs)

            {

                ActivateFeatureRecursively(subWeb, featureId, force, checkForPublishing);

                subWeb.Dispose();

            }

        }

  

        public static void DeactivateFeatureRecursively(SPWeb web, Guid featureId, bool force, bool checkForPublishing)

        {

            if (((checkForPublishing && PublishingWeb.IsPublishingWeb(web)) || !checkForPublishing) && web.Features[featureId] != null)

                web.Features.Remove(featureId, force);

  

            foreach (SPWeb subWeb in web.Webs)

            {

                DeactivateFeatureRecursively(subWeb, featureId, force, checkForPublishing);

                subWeb.Dispose();

            }

        }

        #endregion

  

  

        #region General

  

        public static bool IsInEditMode()

        {

            return SPContext.Current.FormContext.FormMode == Microsoft.SharePoint.WebControls.SPControlMode.Edit || SPContext.Current.FormContext.FormMode == Microsoft.SharePoint.WebControls.SPControlMode.New;

        }

  

        #endregion

    }

}

You can see that I have a method to validate if it’s from the source. This is due to the fact that the APIs for variations only work if you have an SPContext – which you don’t in a Timer Job.

Code – Site Feature Receiver

       1: using System;

       2: using Microsoft.SharePoint;

       3: using Microsoft.SharePoint.Publishing;

       4: using MB.SharePoint.ApplicationLogic;

       5:  

       6: namespace MB.SharePoint.FeatureReceivers

       7: {

       8:     public class VariationOnCreateOnlySite : Microsoft.SharePoint.SPFeatureReceiver

       9:     {

        public override void FeatureActivated(SPFeatureReceiverProperties properties)

        {

            SPSite site = (SPSite)properties.Feature.Parent;

  

            //add column to Page in Site Columns and apply change everywhere

            ApplicationLogic.Utils.AddSiteColumnToContentType(site, new SPContentTypeId(Consts.Guids.contentTypePage), Consts.FieldTypeNames.RichHtml, Consts.Fields.variationOnCreateOnly, false, false, "Allows blocking of variation updates", Consts.Fields.GroupName, "awef");

  

            //Activate the Web Feature on all publishing site

            ApplicationLogic.Utils.ActivateFeatureRecursively(site.RootWeb, new Guid(Consts.Guids.VariationOnCreateOnlyWeb), false, true);

        }

  

        public override void FeatureDeactivating(SPFeatureReceiverProperties properties)

        {

  

            SPWeb web = ((SPSite)properties.Feature.Parent).RootWeb;

            SPContentTypeCollection contentTypes = web.ContentTypes;

  

            //Remove column

            if (web.Fields.ContainsField(Consts.Fields.variationOnCreateOnly))

            {

                //the field is hidden, we cannot delete it until we make it reappear

                SPField field = web.Fields[Consts.Fields.variationOnCreateOnly];

                field.Hidden = false;

                field.Update(true);

            }

  

            SPContentType contentType = web.ContentTypes[Consts.Guids.contentTypePage];

  

            if (contentType != null)

            {

                if (contentType.Fields.ContainsField(Consts.Fields.variationOnCreateOnly))

                {

                    //remove linked field from Content Type

                    if (contentType.FieldLinks[Consts.Fields.variationOnCreateOnly] != null)

                    {

                        contentType.FieldLinks.Delete(Consts.Fields.variationOnCreateOnly);

                        contentType.Update(true);

                    }

  

                    //remove from libraries

                    ApplicationLogic.Utils.DeleteFieldFromAllPagesLists(web, Consts.Fields.variationOnCreateOnly);

  

                    //remove field from Web

                    if (web.Fields.ContainsField(Consts.Fields.variationOnCreateOnly))

                        web.Fields.Delete(Consts.Fields.variationOnCreateOnly);

                }

            }

  

  

            //Deactivate VariationOnCreateOnlyWeb everywhere

            ApplicationLogic.Utils.DeactivateFeatureRecursively(web, new Guid(Consts.Guids.VariationOnCreateOnlyWeb), false, true);

  

        }

  

        public override void FeatureInstalled(SPFeatureReceiverProperties properties)

        {

            //nothing

        }

  

        public override void FeatureUninstalling(SPFeatureReceiverProperties properties)

        {

            //nothing

        }

    }

}

Code – Web Feature Receiver

       1: using System;

       2: using Microsoft.SharePoint;

       3: using Microsoft.SharePoint.Publishing;

       4:  

       5: namespace MB.SharePoint.FeatureReceivers

       6: {

       7:     class VariationOnCreateOnlyWeb : Microsoft.SharePoint.SPFeatureReceiver

       8:     {

       9:         public override void FeatureActivated(SPFeatureReceiverProperties properties)

        {

            //add events

            SPWeb web = ((SPWeb)properties.Feature.Parent);

            SPList pages = web.GetList(web.ServerRelativeUrl.TrimEnd('/') + "/pages");

            ApplicationLogic.Utils.AddEventReceiver(pages, "MB.SharePoint.EventReceivers.VariationsOnCreateOnlyEventReceiver", "MB.SharePoint.EventReceivers, Version=1.0.0.0, Culture=neutral, PublicKeyToken=0ca89b26b6d2ebc5", SPEventReceiverType.ItemAdding, 10000);

            ApplicationLogic.Utils.AddEventReceiver(pages, "MB.SharePoint.EventReceivers.VariationsOnCreateOnlyEventReceiver", "MB.SharePoint.EventReceivers, Version=1.0.0.0, Culture=neutral, PublicKeyToken=0ca89b26b6d2ebc5", SPEventReceiverType.ItemUpdating, 10001);

            ApplicationLogic.Utils.AddEventReceiver(pages, "MB.SharePoint.EventReceivers.VariationsOnCreateOnlyEventReceiver", "MB.SharePoint.EventReceivers, Version=1.0.0.0, Culture=neutral, PublicKeyToken=0ca89b26b6d2ebc5", SPEventReceiverType.ItemUpdated, 10002);

        }

  

        public override void FeatureDeactivating(SPFeatureReceiverProperties properties)

        {

            //remove events

            SPWeb web = ((SPWeb)properties.Feature.Parent);

            SPList pages = web.GetList(web.ServerRelativeUrl.TrimEnd('/') + "/pages");

            ApplicationLogic.Utils.DeleteEventReceiver(pages, "MB.SharePoint.EventReceivers.VariationsOnCreateOnlyEventReceiver", SPEventReceiverType.ItemAdding);

            ApplicationLogic.Utils.DeleteEventReceiver(pages, "MB.SharePoint.EventReceivers.VariationsOnCreateOnlyEventReceiver", SPEventReceiverType.ItemUpdating);

            ApplicationLogic.Utils.DeleteEventReceiver(pages, "MB.SharePoint.EventReceivers.VariationsOnCreateOnlyEventReceiver", SPEventReceiverType.ItemUpdated);

        }

  

        public override void FeatureInstalled(SPFeatureReceiverProperties properties)

        {

            //nothing

        }

  

        public override void FeatureUninstalling(SPFeatureReceiverProperties properties)

        {

            //nothing

        }

    }

}

Code – Event Receivers

       1: using System;

       2: using Microsoft.SharePoint;

       3: using MB.SharePoint.ApplicationLogic;

       4:  

       5: namespace MB.SharePoint.EventReceivers

       6: {

       7:     public class VariationsOnCreateOnlyEventReceiver : SPItemEventReceiver

       8:     {

       9:         //Will set the source and target variation value

        public override void ItemAdding(SPItemEventProperties properties)

        {

            //if not source variation, update variationStatus to source

            using (SPWeb web = properties.OpenWeb())

            {

                properties.AfterProperties[Consts.Fields.variationOnCreateOnly] = Utils.isSourceVariation(properties.RelativeWebUrl, web) ? ApplicationLogic.Consts.Values.variationOnCreateOnlySourceValue : ApplicationLogic.Consts.Values.variationOnCreateOnlyDestinationValue;

                base.ItemAdded(properties);

            }

        }

  

        //Cancel variation depending on where the update originated

        public override void ItemUpdating(SPItemEventProperties properties)

        {

            using (SPWeb contextWeb = properties.OpenWeb())

            {

                string fieldInternalName = contextWeb.Lists[properties.ListId].Fields[Consts.Fields.variationOnCreateOnly].InternalName;

                bool isSourceVariation = Utils.isSourceVariation(properties.RelativeWebUrl, contextWeb);

  

                string updatedValue = isSourceVariation ? Consts.Values.variationOnCreateOnlySourceValue : Consts.Values.variationOnCreateOnlyDestinationValue;

                string afterValue = (string)properties.AfterProperties[fieldInternalName];

  

                bool isUpdatingFromSource = false;

                if (afterValue != null && properties.ListItem != null && properties.ListItem[fieldInternalName] != null)

                    isUpdatingFromSource = isSourceVariation ? true : (afterValue.Equals(Consts.Values.variationOnCreateOnlySourceValue) && !properties.ListItem[fieldInternalName].Equals(Consts.Values.variationOnCreateOnlySourceValue));

                bool cancel = !isSourceVariation && isUpdatingFromSource;

  

  

                if (cancel)

                {

                    properties.Status = SPEventReceiverStatus.CancelNoError;

                    properties.Cancel = true;

                }

                else

                {

                    DisableEventFiring();

                    properties.AfterProperties[fieldInternalName] = updatedValue;

                    base.ItemUpdating(properties);

                    EnableEventFiring();

                }

            }

        }

  

        //in some scenario, pages already created before activating the site collection, this ensures a value in the 

        public override void ItemUpdated(SPItemEventProperties properties)

        {

            using (SPWeb contextWeb = properties.OpenWeb())

            {

                string fieldInternalName = contextWeb.Lists[properties.ListId].Fields[Consts.Fields.variationOnCreateOnly].InternalName;

                bool isSourceVariation = Utils.isSourceVariation(properties.RelativeWebUrl, contextWeb);

                string updatedValue = isSourceVariation ? Consts.Values.variationOnCreateOnlySourceValue : Consts.Values.variationOnCreateOnlyDestinationValue;

  

                if (!properties.ListItem[fieldInternalName].Equals(updatedValue))

                {

                    DisableEventFiring();

                    properties.ListItem[fieldInternalName] = updatedValue;

                    properties.ListItem.SystemUpdate(true);

                    EnableEventFiring();

                }

            }

        }

    }

}

Note: I think I can be good without the ItemUpdated now but I’ll have to re-run a full test run to validate.

Here is the complete solution to this. The WSP will install all of this and will staple on the out of the box Publishing Site with and without Workflows (+ press release). The Features and Site Column aren’t hidden – this was to help validate and debug – and you can make them hidden if necessary.

Note: The key is password-protected, just skip the password and create your own if you want to recompile. You’ll want to change the feature manifests for your key and the VariationOnCreateOnlyWeb.cs file.

Disclaimer : Note, this code is provided *AS IS* and no support is available from Microsoft. While I will do what I can – when I can – to help you find a problem in the code, this code should be tested thoroughly in your environment before sending in production.

As a last note, I believe this solution to be the next best solution if you do not want an empty source variation (for creation only) but do not want to erase target pages at each source update. The reason for this is that it’s not breaking up the OOB feature, we can stop this at any time without impact, and there are no errors in the logs.

Reapplying changes from a customized file originally deployed through features

MaximeB — Fri, 31 Jul 2009 22:16:32 GMT

In most if not all scenarios, you will be deploying your files (Page Layouts, Master pages, CSS, JavaScript, etc.) through a Feature. If you leave them as is, they are called “Uncustomized” and will reference the files on disk. Any updates to the files – which you would normally do through a solution upgrade – would automatically be available live (it takes an application pool recycles, which the upgrade solution does) to all site collections that has that feature activated.

In some scenarios, especially in larger IT groups where creating the solution package for “Containers” (artefacts between Code (IT) and Content (Business) – but it’s really closer to the Business) may take some time, updates may be done online to one of those files to fix a problem. These updates could be done through the Web UI or through SharePoint Designer, albeit the later is rarely allowed in production environments.

Change Management is still recommended and testing should be done prior to updating any files in production – this is just a different deployment vehicle – one that is already available if you have enough permissions on the web site.

The problem is that once this update occurs, the file becomes “customized” – this is well known. If you were to go in SharePoint Designer, you could see a blue icon next to the file (to be honest, with SP2, I had that on any files but Page Layouts) which tells you it’s customized. You can right-click and “revert to definition” through SharePoint Designer, but as mentioned earlier, SPD is probably not available on the production environment. What happens the next time you update your Feature is that the file on disk will contain your updates, but the site where customization occurred will not be updated – all of this is well known and was as such with SharePoint 2003.

If you’d like to force your Feature to be the ‘master’ and remove any customizations, you can use a Feature Receiver that will, on activation, validate each files in the Feature manifest and use the SPFile.RevertToContentStream() method. This is essentially what the option in SharePoint Designer calls.

        1: using System;

       2: using System.Collections.Generic;

       3: using System.Xml;

       4: using System.Text;

       5: using System.Globalization;

       6: using Microsoft.SharePoint;

       7: using Microsoft.SharePoint.Administration;

       8: using Microsoft.SharePoint.Utilities;

       9:  

namespace MB.SharePoint.FeatureReceivers

{

    class RevertFilesToDefinitionFeatureReceiver : SPFeatureReceiver

    {

        public override void FeatureActivated(SPFeatureReceiverProperties properties)

        {

            try

            {

                SPWeb web = ((SPSite)properties.Feature.Parent).RootWeb;

                CultureInfo ci = System.Globalization.CultureInfo.InvariantCulture;

                SPElementDefinitionCollection elementFiles = properties.Definition.GetElementDefinitions(ci);

  

                foreach (SPElementDefinition elementFile in elementFiles)

                {

                    try

                    {

                        XmlNode content = elementFile.XmlDefinition;

                        XmlDocument contentDoc = new XmlDocument();

                        contentDoc.LoadXml(content.OuterXml);

  

                        XmlNamespaceManager xmlNamespaceManager = new XmlNamespaceManager(contentDoc.NameTable);

                        xmlNamespaceManager.AddNamespace("ns", "http://schemas.microsoft.com/sharepoint/");

  

  

  

                        //check for an elementfile

                        if (content.Name == "Module")

                        {

                            XmlNode xmlModule = elementFile.XmlDefinition;

                            SPFolder spFolder = web.GetFolder("/" + xmlModule.Attributes["Url"].Value);

                            SPDocumentLibrary spDocumentLibrary = (SPDocumentLibrary)web.Lists[spFolder.ContainingDocumentLibrary];

  

                            foreach (XmlNode xmlFile in xmlModule.SelectNodes("ns:File", xmlNamespaceManager))

                            {

                                SPFile spFile = web.GetFile(String.Concat(xmlModule.Attributes["Url"].Value, "/", xmlFile.Attributes["Url"].Value));

                                if (spFile != null && spFile.CustomizedPageStatus == SPCustomizedPageStatus.Customized)

                                    spFile.RevertContentStream();

                            }

                        }

                    }

                    catch (Exception ex)

                    {

                        //absorbing error (so that other files can try), you'll want to log here

                    }

                }

            }

            catch (Exception ex)

            {

                //absorbing error, you'll want to log here

            }

        }

  

        public override void FeatureDeactivating(SPFeatureReceiverProperties properties)

        {

        }

  

        public override void FeatureInstalled(SPFeatureReceiverProperties properties)

        {

        }

  

        public override void FeatureUninstalling(SPFeatureReceiverProperties properties)

        {

        }

  

    }

}

Simply package this in your libraries and add the Feature Receiver Assembly & Class in your original feature definition. You can download the latest version of my public code solution here :

Sincerely,

Maxime

Experiences on using a single farm for developers (WCM)

MaximeB — Mon, 06 Jul 2009 22:42:34 GMT

Scenario:

5-8 developers
WCM portal with lots of sites (SPWeb) and pages, but not a large database
Development is focused on Fields, Content Types, Layouts, Web Parts, Controls, HttpModules

Typical environments:

The general recommendation is for developers to have their own virtual machine (or physical machine) that contains a complete SharePoint installation. There’s a variant where the SQL Server is shared but it will still be several SharePoint farms with a single server in each.

The problem with these is that you end up with multiple farms to manage. This can work good for the first deployment but will be difficult for incremental releases. It can also be good for developers working for different production environments.

However, when developers are working for a single production environment, other requirements will come in:

Download content artefacts from Production to Development (especially for WCM or light collaboration scenarios)
Update all developer environments with new artefacts
Update all developer environments with new or updated layouts & styles
Update all environments with a new CU or service pack

Developers already had those requirements without impacting anyone else:

Update file system files in the web folder (web.config, browser file, etc.)
Execute an IISRESET
Update assemblies

What impact would a single farm have for development?

After living with multiple farms using shared resources, I implemented a single farm at a customer. While there are identifiable caveats, it also bring a lot of value while diminishing overall time spent on maintenance and on bug due to non-synchronized environments.

For WCM, you will have 2 types of development : 1) content related and 2) pure development artefact. The first is easy to handle, your web designer can simply work like before and it will generally not impact anyone else, in fact, it’s beneficial since page layouts will be updated for everyone at the same time.

The only drawback is that I’ve often seen web designers doing check-ins or publishing layouts to test them. This isn’t optimal for anyone as it uses more resources on SharePoint and if the layout has a display issue, everyone will have it. Therefore, some assistance (how-to’s) should be planned to ensure that web designers are working optimal for everyone.

For Development artefact, it can be a little bit more complicated depending on what type of artefact. For example, if you are developing a custom SharePoint Field, results will be inconsistent if you add a new field instance to a content type that is used for everyone. In the same fashion as the previous case, working on a separate site collection (or at least content type) might be a more manageable solution for the few times when you are developing those artefacts.

In fact, for most cases, it’s the visibility that is more important than the actual change. The reason for this is that a single developer working on a custom Field or a Web Part will only work on his development machine for obvious reason. If the farm + web application + site collection are shared, then we may have to create an unused sub-site for testing purposes during the development.

While this may seem cumbersome, at least on “paper”, it’s actually quite simple and is much simpler to manage than multiple environments. This allows to have less requirements on the development workstations and resources are shared – the database/disk/backups footprint is lessen.

Mixed topology

At the next level, you can have the bulk of your development done in a single shared farm but this doesn’t mean you cannot have 1 or 2 other farms for specific development artefacts if they prove too cumbersome. For example, you may want to have a specific farm (with content) used for various special operations such as testing new CU/Service Packs, 3rd party tools and solutions, etc. All without affecting your standard integrated testing environment – it’s still easier to maintain 2 farms than 8-10.

I had a scenario where we created a development farm for support. It’s purpose was to test anything else that wasn’t in the standard development line.

Conclusion

So far, I’ve had good success with the single farm topology. There is some added governance to be done while implementing – primarily for developers and web designers – but this ensures that you have a good definition of what type of work is being done and which one you wishes to support.

On a daily basis, developers didn’t have a negative impact due to improper updates by someone else. On a longer basis, management was much easier, especially with content updates and patches – we are now 100% positive that everyone sees the same thing.

While this may not be ideal for some situations, it certainly proved to be working well for WCM development.

Bringing SharePoint Certified Master (MCM) to Canada

MaximeB — Thu, 02 Jul 2009 15:16:39 GMT

On June 1st, I started the Microsoft Certified Master (MCM) : SharePoint journey with 16 other candidates from across the world. I can proudly say today that I successfully met all requirements to pass the first ‘RTM’ SharePoint Master rotation.

This has been an incredible experience and by far the best professional training I’ve ever attended in nearly 14 years of development experience. It’s challenging, it’s tough, it’s time-consuming – but it’s also extremely rewarding, valuable, and worth the investment (both personal/time and financial). While you will learn a lot on SharePoint (especially how much you didn’t know to begin with), you will also meet several other experts with who you will share a connection – you have been selected through a rigorous review as a candidate for SharePoint Master. This stays. This is true value over time.

I’m also very proud to be amongst the first Canadian to become an MCM SharePoint – I had a fellow Canadian candidate on the RTM rotation – and will be able to share this experience with both French and English audiences.

There was discussions on the value of going for MCM SharePoint 2007 while knowing that SharePoint 2010 is coming out – the first rotation of SharePoint MCM 2010 is scheduled for next year. Personally, I’m very happy to have done this one for several reasons : (1) There are a lot of customers with 2007 today and more will be on SharePoint before 2010 comes out; (2) We will have to migrate to 2010 which means a good knowledge of 2007 to start with; (3) There is a lot to learn on SharePoint 2007 in only 3 weeks, 2010 will also be 3 weeks and there will be even more to learn! (4) it was announced that there will be an upgrade path from MCM SharePoint 2007 to 2010.

If you are wondering if the cost is worth it, especially for non-Microsoft employees – I haven’t heard a single partner mention that they didn’t get their investment’s worth. If you compare this to any other training program – it will still cost several thousands for 3 weeks and it won’t begin to compare. You have access to several worldwide experts on the product. You have access to incredible hardware to test whatever you need on SharePoint (multi-farm / domains included!). You get to not only learn the best from the best, but also share with them. Also, discounts and new dates have been announced on the master’s blog.

As an ending comment : Be prepared – both technically, mentally, and physically. Don’t assume you will breeze through it – you won’t and nobody did. You will get what you will put into it and be very proud of it. Hope to see more of you in the MCM community soon!

Variation strategy to reduce labels overwrite

MaximeB — Sun, 21 Jun 2009 07:47:52 GMT

There is a lot of discussions and articles on SharePoint Variations which contains good arguments on why the feature isn’t all what it’s prepped up to be. This will not be a post to debate whether they are useful or not but merely how to make them more useful than what I see in the field.

Update: Variation Strategy #2 available at http://blogs.msdn.com/maximeb/archive/2009/08/01/variation-strategy-2-to-remove-label-overwrites-cancel-updates.aspx

First of all, when discussing variations with a customer, he’s likely to be sold on the ‘multilingual’ bullet from a PowerPoint slide. I sometime hear that the feature should do a complete translation automatically (nothing less :)). The first thing about Variations is to know when to recommend them and when they aren’t useful enough. After that, the next thing is to have a good discussion with the customer about what it means to use variations.

Here’s a few quick and simple facts on Variations:

Variations are simply a mechanism to provision sites and publishing pages between multiple labels.
You can have a single set of variations per site collection
You can only have a one ‘source’ variation
By default, and in most cases, any published updates in the ‘source’ variation will be replicated on all other labels as a minor version.
There is also a web part that allows you to select a page in another language.

Problem #1 : Information Architecture usually picks the customer’s default language as the source variation

While this should make sense, the default language is usually also the one with the most content updates. For example, you set ‘English’ as the source label, and you create 2 labels ‘French’ and ‘Spanish’.

For the ‘Go-Live’, you create all your content in English and it will copy it over in the other 2 labels. You will have translators going over and fixing your other labels.

Within a couple days (if not before the Go-Live), you start updating content in your English label and authors start complaining in the other 2 labels as their localized content is ‘reverted back in English’.

What happens is that the French Version 1.0 of a page got bumped by a v.1.1 in English. While the author can edit the page, go back in history and revert the 1.0, he will have to re-approve/publish the page as a 2.0. This is very annoying indeed.

Problem #2 : While you may want to translate everything for a Go-Live, you probably don’t later

Ask your customer if they really want to translate their complete web site all the time? This is usually not the case. They may want their press releases but not all news as they are more targeted. They may want their products or maybe only a segment of products (i.e.: Corp products versus localized offerings).

Problem #3 : Documents aren’t copied over the other labels

Well that' one’s a simple fact, variations are only for publishing pages. In my experience, while some documents are clearly desired in a few languages, all the documents in the sites are unlikely to be required as translated.

Also, I often see more of a need of a ‘document set’ where you want to see all languages available for a document from any site (i.e.: show me the French and English document in both the French and English site).

Problem #4 : Some customers think that it’s all automated

It’s not. Simple. A human is required as the glue in between. The feature does provide a way to export a label (or a section) and there are 3rd-party products that can take that export and provide a system for translators to work more convivially, but there’s a still a human involved.

Problem #5 : Creating labels is buggy

Well that’s true but SP2 fixed it by providing an STSADM to create labels. The problem was that it took too long for the web process to finish the creation and you were left hanging.

Problem #6 (misconception really) : You should not edit content in other labels than the source except to localize content

That’s simply not true. You can author as much as you want in all labels. The worst that can happen is if you create a site or a page in a sub label; and then you try to create a content with the same name in the source variation. What will happen is that content from the source will not be pushed down on that sub label only.

This isn’t necessary bad actually, and the variation log will tell you the issue and you can resolve it if necessary.

Solutions?

Well if you want to think outside the box, you can surely come up with some workflows or custom events to do the work. Is it worth it? Maybe if you really need all the content to be brought on all languages only one time, but hardly.

OOB solution? Create a ‘non-visitor’ source variation!

In my opinion, you usually need roughly 30% of your content in all languages, give or take. But this works even if you have 100%! What this source variation is simply a ‘creator’. If you need content for all labels, that’s the place to go. If you need to update a page’s content with something major for all labels, that’s the place to go and then you’ll have to update all labels.

But when you want to change a typo or add some comments in one language, that’s not the place to go.

So in our previous sample, we had 3 labels required : English, French, and Spanish. Instead of picking up English as the source, create a label called ‘Source’ or ‘GlobalContent’ (or something that makes most sense to your authors). This ‘Source’ will be in English but your visitors will not go there.

In order to do that, you can either pick a label language that isn’t yours (i.e.: if you are in the US only, pick English UK as your source; and then English US for the English sub label). The other way is to customer the Variation Root Landing logic (http://msdn.microsoft.com/en-us/library/ms562040.aspx).

Alright, so now you have 4 variations instead : Source (English UK), English US, French, and Spanish. You will probably have few Contributors in your source variation, maybe only Hierarchy Managers. You would then set appropriate permissions in your labels only.

Remember, only create or update content in the ‘Source’ when it’s global. When it’s not, authors should go in their respective label and simply create it there. This is totally safe and supported.

This way, you will rarely erase ‘French’ or ‘Spanish’ content with ‘English’ at each update. If you define your information architecture and governance right, and you explain the variation process accordingly with your customer and content authors, this will probably be the simplest solution for variations and should cover most of your customer’s needs.

Extending a Web Application will redeploy your solutions ... watch for manual GAC updates

MaximeB — Wed, 01 Apr 2009 14:58:00 GMT

I was helping a customer yesterday that had an unexplained issue in production, a Web Part was behaving as if it had rolled back its code. As it turns out, the following happened:

WSP containing DLLs to install in the GAC was deployed some time ago
A bug was discovered in production and there was time constraints in creating the quick fix through a WSP (permission issues)
The fix was applied in the DLL and they were manually deployed in the GAC
The WSP was also updated but never redeployed in production
IT Admins extended the Web Application to debug another non-related situation
The original WSPs were redeployed in the farm and the 'old' DLL was brought back

Debugging this obviously took some time, until we could have access to the production server to download the DLL in the GAC and disassemble it, but shows how bad a practice it is to have manually updated DLLs in the GAC that were originally deployed from WSP.

Unfortunately, Best Practices goes only so far where we recommend using WSPs and sometimes we understand the benefits but not consequences such as this one. There may be other operations that could redeploy solutions such as adding a farm server or installing a CU or SP but I didn't confirm this.

So all in all, if you have to manually update a deployed-through-WSP-DLL in the GAC, for whatever (political) reasons (which is usually because of permissions or rigid processes), plan to update the WSP as soon as possible.

Non-extended public AAM will not allow you to set anonymous access

MaximeB — Wed, 01 Apr 2009 14:49:30 GMT

I had a customer that was having issues setting the anonymous access. While they could access the http://contoso/_layouts/setanon.aspx page, they couldn't actually see the link to that page when navigating to the Site Permissions.

When they were loading up the page, the "Entire Web Site" and "Lists and Libraries" were disabled allowing only the "None" radio button available. As it turns out, they were accessing a correctly configured Alternated Access Mapping as a public URL for their site, however, the 'setanon.aspx' admin page requires the access to be through a zone configured in the "Authentication Providers" for that Web Application.

What this customer had was a Default zone and Internet zone configured correctly (where the Internet zone was a Web Application extension), both of which are under a reverse proxy for external access. The reverse proxy does SSL termination as well so the actual MOSS servers do not have an SSL certificate.

They also had 2 other URLs used internally (Intranet public AAMs) so that it doesn't go through the publishing rule and thus allow administrators to access any server by specifying a host file. While they could have a host file for the published URL, there would be an issue as it expects SSL.

They could have set the anonymous access through the published anonymous URL (while being authenticated). If they would have absolutely liked to have the intranet URL to allow configuring anonymous, they would have had to remove their AAMs and then extend the Web Application for these AAMs. When you extend a Web Application, it creates an Authentication Provider configuration for that zone.

As a site note, if you did configure the anonymous access in the past and then you access through a non-extended URL, the radio buttons will still be disabled but selected (i.e.: Entire Web Site will be disabled but you can only set the value to None and not back to Entire Web Site).

Content By Query issue with audiences filtering

MaximeB — Thu, 26 Mar 2009 17:35:21 GMT

A few months ago, I came across this issue where the number of returned items in a query wasn’t as expected.

Context with normal queries

To contextualize, let’s say you have a home page with several articles section which are in turned served by Content By Queries. Your queries will either target a specific article sub-site or it will use metadata to query something like :

SELECT TOP 5 Article.Title FROM Article-Site-URL [WHERE MetadataA='value'] ORDER BY LastUpdated DESC

This will show the last 5 updated articles from that site, and if necessary filtered by a metadata.

With daily data being added to all article categories, your home page design is designed to display 5 articles in each category. Usually no less, but certainly no more than 5 items.

Context with audiences

Now if you have an authenticated portal and you’d like to have such an article section with targeted content. For example, the articles are regrouped by a logical business meaning but they are targeted to different groups of users. You will use the same Content By Query and check the “Filter results by audiences” to have only the articles for that user’s audiences. You would expect the “Top 5” to work correctly.

Unfortunately, the query resembles more something like :

SELECT Article.Title FROM (SELECT TOP 5 Article.Title FROM Article-Site-URL ORDER BY LastUpdated DESC) WHERE Article.TargetAudiences CONTAINS (Users.AudiencesGUIDs)

If you look closely at the query, it does a standard TOP 5 query in the content without an audience check. This first query may return 5 items but after the audience filtering, 0 to 5 items will be displayed to the user.

The query should rather be something like :

SELECT TOP 5 Article.Title FROM Article-Site-URL WHERE Article.TargetAudiences CONTAINS (Users.AudiencesGUIDs) ORDER BY LastUpdated DESC

**note: the queries aren’t like this in the APIs, I simply simplified them for explanation**

For a customer using audiences, it can be a show-stopper as you cannot effectively plan your home page queries. The only workaround was to “augment the limit of items return” but since you cannot effectively plan how much you will need, it will break the home page’s layout by either showing too many articles or not enough.

Fix!

Originally, it was apparently by-design and wouldn’t be updated until the next release of Office 14. Fortunately, I’m very happy to have received news that it will be released in an upcoming Cumulative Update along with the fix for multiple audiences explained here.