A people directory can be useful if you want to list all the people in an organisation without users having to enter a search query. Users can then narrow down the list using filters such as Department or Job Title to narrow the results. This is really easy to set up using the default SharePoint 2013 search web parts and doesn’t require writing a single line of code. An example of what this can look like is shown below:

Especially when the organisation only contains a few hundred people this can help users discover people in the organisation without necessarily knowing their names. The steps to create this are as follow (assuming the user profile and search services are running successfully):

1. Assuming you have an enterprise search center set up the first step to create the people directory is to enable the people search page layout so we can create a people search results page. This can be done by navigating to the Site Settings > Look and Feel | Page layouts and site templates page and selecting ‘(Welcome Page) Search People’ in the Page Layouts section.
   
2. The next step is to navigate to the pages library and select New Document > Page from the ribbon.
   
3. On the create page screen select the Search People page layout to create a page that contains the people search results web parts.
   
4. The standard search result web part does not show any results unless a query is specified. To get all people to show up by default we need to modify the query used by the People Search Core Results web part. This can be done by clicking the ‘Change Query’ button in the web part properties and adding a property filter that returns all people. To do this we can select the property ‘contentclass’ and enter the manual value ‘spspeople’.
   
5. We now have a list of people that will be displayed as soon as the user navigates to our custom people results page. By default we also have some refinements that appear if matching metadata is found within the result set. These are the Department, Job Title, Keywords and Office Location columns. We can change these to show other metadata properties that are defined in our search centre by selecting the ‘Choose refiners’ option on the refinement web part. Note that the managed property must have the ‘Refinable’ option selected in the search schema for it to be available in this list.
   

Adding Sorting by Last Name

Adding additional sort options is much easier than in SharePoint 2010. To add a custom sort option such as Last Name follow the steps below:

1. Ensure that the managed property you want to sort by has the Sortable option enabled in the search schema. To do this navigate to the Search Service Application > Search Schema, click the LastName managed property and select the Sortable: ‘Yes – active’ option. Note you will need a full crawl for this to take effect.
   
2. On the search results page edit the People Search Core Results web part, check the ‘Show sort dropdown’ option and enter the following text:
   [{"name":"First name (A-Z)","sorts":[{"p":"FirstName","d":0}]},{"name":"First name (Z-A)","sorts":[{"p":"FirstName","d":1}]},{"name":"Last name (A-Z)","sorts":[{"p":"LastName","d":0}]},{"name":"Last name (Z-A)","sorts":[{"p":"LastName","d":1}]},{"name":"Social distance","sorts":[]}]
3. You should now be able to sort by first or last name in alphabetical order either A-Z or Z-A.
   

Using a Table Based Layout

Another option for the people directory is to use a table based layout with column headers for properties. In SharePoint 2013 this can be done using Display Templates. In this case we need to use two display templates – a control template for the table header, and a item template for each search result item. The steps to implement this are shown below.

1. The first step is to add the display templates to the masterpage gallery by selecting Site Settings > Master Pages and Page Layouts > Display Templates > Search and upload the two html files from the following .zip archive.
   PeopleDirectoryDisplayTemplates.zip
2. The next step is to edit the search core results web part and in the Display Template section set the Results Control Display Template to ‘Table Result’ and the Item Display Template to ‘People Table Item’.
   
3. You should now see the results displayed as a table based layout as shown below:

If you have worked with previous versions of SharePoint you can see that in SharePoint 2013 the search features are much richer and easier to work with. There are also a number of new features such as query rules and extensibility options such as customising the hover panel that enhance the end user search experience.

How to: Create a Simple SharePoint 2013 People Directory is a post from: SharePoint Config

IT112/IT113 Upgrading SharePoint

In these sessions on upgrading to SharePoint 2013 we will walk through the various upgrade options and how to carry out the server preparation and installations for your upgrade testing deployments. We will use a real world dataset to verify upgrade compatibility and troubleshoot some common upgrade issues you may encounter and how to progress forward. This session is for IT Professionals, System Administrators who want to know how to approach and carry out an upgrade/migration to 2013. I’ll also talk about how to upgrade custom developed SharePoint solutions built for earlier versions of SharePoint.

COM711 Case study: Industry wide collaboration

Discover how we used SharePoint as a platform to facilitate collaboration between hundreds of different telecom organisations worldwide. The project involved building a LinkedIn like website that contains company and user details for the mobile industry. In a similar way to LinkedIn, users can also request to join groups and communicate and collaborate on certain topics such as Roaming to Fraud. The project also involved many other features specific to the mobile industry such as the ability to to store mobile network information and document management features that allow groups to work on official standards documents for the mobile industry.

This session will include a run through of the functional areas of the system and an explanation of how each area was built from a technical perspective. We will also cover some of the challenges we faced when building a system that is used by over 800 different organisations in over 200 countries around the globe.

A couple of pages from the site are shown below. The image below shows the homepage of the extranet including document and people feeds, personalised lists of contacts, meetings and task information.

We also made many enhancements to the document management features. The image below shows the landing page for an official document. As well as metadata about the document and files to download the page contains a list of related official documents and the status of change requests that relate to changes to the document.

I’m really looking forward to the conference and hope to see some of you there!

I’m speaking at the SharePoint 2013 Evolution Conference is a post from: SharePoint Config

Step 1: Extend the search core results web part to support sorting

There are two search core results web parts that are capable of displaying list of people:

• Search Core Results – provides a generic way of displaying search results and supports sorting by relevance and modified date
• People Search Core Results – provides additional people based information in search results and supports sorting by relevance, social distance and name (a-z only)

As both the web parts only allow a fixed set of sorting options we need to create a new web part if we want to provide sorting options such as by last name or by first name (z-a). The easiest way to do this is to inherit from an existing web part and as the people search core results is sealed we can only do this by inheriting from the search core results web part.

One benefit of using the search core results web part is that we are not limited to displaying lists of people. We can use this web part to display sortable lists of documents, list items, sites or any other information in the search index. This is a very useful technique for aggregating content from across several site collections or across a large number of sites where web parts such as the content query web part run into performance problems (in fact SharePoint 2013 introduces the content by search web part which is based on the same principals we use here).

In the class that extends the search core results web part we can add code that changes the order by clause of the search query. Bart-Jan Hoeijmakers has an excellent post on Creating a sortable CoreResultsWebPart in SharePoint 2010 that shows how to do this. I’ve extended his web part in the example below to changes the sort order based on query string parameters, or properties of the web part if there are no parameters passed in.

using System;
using System.ComponentModel;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using Microsoft.SharePoint;
using Microsoft.SharePoint.WebControls;
using Microsoft.Office.Server.Search.WebControls;
using Query = Microsoft.Office.Server.Search.Query;

namespace Ari.SharePointSearch.WebParts
{
    [ToolboxItemAttribute(false)]
    public class SortableCoreResults : CoreResultsWebPart
    {
        [Personalizable(PersonalizationScope.Shared)]
        [WebBrowsable(true)]
        [WebDisplayName("Default managed property")]
        [WebDescription("Sort by this managed property by default")]
        [Category("Sorting Properties")]
        public string OrderByProperty { get; set; }

        [Personalizable(PersonalizationScope.Shared)]
        [WebBrowsable(true)]
        [WebDisplayName("Default direction")]
        [WebDescription("Default sorting direction")]
        [Category("Sorting Properties")]
        public Microsoft.Office.Server.Search.Query.SortDirection SortDirection { get; set; }

        /// <summary>
        /// Runs the base configuration then adds a custom sort property
        /// </summary>
        protected override void ConfigureDataSourceProperties()
        {
            // only run when we are showing search results (e.g. not the search action links)
            if (this.ShowSearchResults)
            {
                try
                {
                    // run the base code
                    base.ConfigureDataSourceProperties();

                    // get the sorting parameters off the query string
                    string orderByProperty = this.Context.Request.QueryString["v1"];
                    string sortDir = this.Context.Request.QueryString["SortDir"];

                    // if none set use the defaults
                    if (string.IsNullOrEmpty(orderByProperty))
                        orderByProperty = OrderByProperty;

                    Query.SortDirection sortDirection = SortDirection;

                    if (!string.IsNullOrEmpty(sortDir) && sortDir.ToLower() == "desc")
                        sortDirection = Query.SortDirection.Descending;
                    else if (!string.IsNullOrEmpty(sortDir) && sortDir.ToLower() == "asc")
                        sortDirection = Query.SortDirection.Ascending;

                    CoreResultsDatasource dataSource = this.DataSource as CoreResultsDatasource;

                    // if we have an orderByProperty then modify the search query sort order
                    if (!string.IsNullOrEmpty(orderByProperty))
                    {
                        dataSource.SortOrder.Clear();
                        dataSource.SortOrder.Add(orderByProperty, sortDirection);
                    }
                }
                catch (Exception ex)
                {
                    // implement exception handling here

                }
            }
        }

        protected override void ModifyXsltArgumentList(Microsoft.SharePoint.WebPartPages.ArgumentClassWrapper argList)
        {
            base.ModifyXsltArgumentList(argList);

            // add a parameter with the current URL
            argList.AddParameter("CurrentUrl", string.Empty, HttpContext.Current.Request.Url.PathAndQuery);
        }
    }
}

This web part now lets us set a default sort option by passing in parameters on the query string. For example if we load the page the web part is on with parameters such as peopledirectory.aspx?v1=LastName&SortDir=asc the web part will sort the results by last name A-Z.

We can also set the default sorting option by using the sorting properties that are shown when editing the web part. This will be used to sort the results when the query string parameters are not present.

Step 2: Extend the search results XSLT to render additional sorting options

The second step is to change the XSLT that renders the sort by drop down to include additional sorting options. When a different sort option is selected the property and the direction (i.e. ascending or descending) will be passed on the query string to the core results web part we created in step 1.

I’ve included an example of how to add first name and last name sorts both ascending (a-z) and descending (z-a) below:

        <xsl:if test="$ShowDropDown = 'true'">
          <xsl:value-of select="$SortBy" />
          <select id="dropdown" title="{$SortOptions}" onchange="PostToUrl(this.value)" class="srch-dropdown">
            <xsl:call-template name="AddSortOption">
              <xsl:with-param name="DisplayName">First name (A-Z)</xsl:with-param>
              <xsl:with-param name="ManagedProperty">FirstName</xsl:with-param>
              <xsl:with-param name="Direction">Asc</xsl:with-param>
            </xsl:call-template>
            <xsl:call-template name="AddSortOption">
              <xsl:with-param name="DisplayName">First name (Z-A)</xsl:with-param>
              <xsl:with-param name="ManagedProperty">FirstName</xsl:with-param>
              <xsl:with-param name="Direction">Desc</xsl:with-param>
            </xsl:call-template>
            <xsl:call-template name="AddSortOption">
              <xsl:with-param name="DisplayName">Last name (A-Z)</xsl:with-param>
              <xsl:with-param name="ManagedProperty">LastName</xsl:with-param>
              <xsl:with-param name="Direction">Asc</xsl:with-param>
            </xsl:call-template>
            <xsl:call-template name="AddSortOption">
              <xsl:with-param name="DisplayName">Last name (Z-A)</xsl:with-param>
              <xsl:with-param name="ManagedProperty">LastName</xsl:with-param>
              <xsl:with-param name="Direction">Desc</xsl:with-param>
            </xsl:call-template>
          </select>
        </xsl:if>

This relies on a couple of helper templates to create the hyperlink containing the relevant query string parameters. These templates are shown below:

  <xsl:template name="AddSortOption">
    <xsl:param name="DisplayName"/>
    <xsl:param name="ManagedProperty"/>
    <xsl:param name="Direction"/>

    <xsl:variable name="UrlWithSortProperty">
      <xsl:call-template name="ReplaceQsParameter">
        <xsl:with-param name="URL" select="$CurrentUrl"/>
        <xsl:with-param name="ParamName">v1=</xsl:with-param>
        <xsl:with-param name="ParamValue" select="$ManagedProperty"/>
      </xsl:call-template>
    </xsl:variable>

    <xsl:variable name="UrlWithSortAndOrderProperties">
      <xsl:call-template name="ReplaceQsParameter">
        <xsl:with-param name="URL" select="$UrlWithSortProperty"/>
        <xsl:with-param name="ParamName">SortDir=</xsl:with-param>
        <xsl:with-param name="ParamValue" select="$Direction"/>
      </xsl:call-template>
    </xsl:variable>

    <option value="{$UrlWithSortAndOrderProperties}">
      <xsl:if test="$UrlWithSortAndOrderProperties = $CurrentUrl">
        <xsl:attribute name="selected">selected</xsl:attribute>
      </xsl:if>
      <xsl:value-of select="$DisplayName"/>
    </option>

  </xsl:template>

  <xsl:template name="ReplaceQsParameter">
    <xsl:param name="URL"/>
    <xsl:param name="ParamName"/>
    <xsl:param name="ParamValue"/>
    <xsl:choose>
      <xsl:when test="contains($URL, $ParamName)">
        <xsl:variable name="Before" select="substring-before($URL, $ParamName)"/>
        <xsl:variable name="After" select="substring-after(substring-after($URL, $ParamName), '&amp;')"/>
        <xsl:choose>
          <xsl:when test="$After = ''">
            <xsl:value-of select="concat($Before, $ParamName, $ParamValue)"/>
          </xsl:when>
          <xsl:otherwise>
            <xsl:value-of select="concat($Before, $ParamName, $ParamValue, '&amp;', $After)"/>
          </xsl:otherwise>
        </xsl:choose>
      </xsl:when>
      <xsl:when test="contains($URL, '?')">
        <xsl:value-of select="concat($URL, '&amp;', $ParamName, $ParamValue)"/>
      </xsl:when>
      <xsl:otherwise>
        <xsl:value-of select="concat($URL, '?', $ParamName, $ParamValue)"/>
      </xsl:otherwise>
    </xsl:choose>
  </xsl:template>

I’ve also modified the XSLT to display the results in a table based layout as per my previous post on creating a SharePoint 2010 people directory with a table based layout.

If you want the complete code packaged up you can download the solution package for the search core results web part. Note this is a farm solution as the search core results web part cannot be extended using a sandboxed solution.

Once you have deployed the solution the steps below can be used to add the sortable search results web part to a search results page:

1. Activate the ‘Sortable Core Results’ site collection feature
2. Assuming you have an enterprise search center set up the next step is to create a new search results page by selecting Site Actions > New Page from the search site.
3. On the search results page delete the Search Core Results web part
4. In the bottom web part zone click ‘Add a Web Part’ and select the ‘Sortable Core Results’ web part from the Search category
5. Delete the Search Action Links web part
6. In the middle lower right web part zone click ‘Add a Web Part’ and select the ‘Sortable Core Results’ web part
7. Modify the sortable core results web part in the middle right zone and under the miscellaneous section deselect ‘show search results’ and select ‘show action links’

You should now have a page that displays a list people with a drop down that allows users to sort by first name or last name A-Z or Z-A.

The example solution uses a table based layout but it is also possible to use a layout similar to the people search results by changing the XSLT file used to render the results.

Download the solution package for the search core results web part

Additional resources

• Creating a sortable CoreResultsWebPart in SharePoint 2010
• Make Core Results Web Part Sortable on other columns
• How to: Create a Simple SharePoint 2010 People Directory
• SharePoint 2010 People Directory Part 2 – Table Layout

SharePoint 2010 People Directory Part 3 – Sorting is a post from: SharePoint Config

Office 2013 Launch Event and Overview

A good place to start is the webcast of the official Office 2013 launch event from Microsoft. If you prefer reading rather than watching the Engadget article Microsoft Office 2013 preview: details, screenshots and impressions gives a good overview of the Office 2013 features. Some of the big changes are that Office has been redesigned to work with touch devices and integrates heavily with the cloud including SkyDrive and Skype integration. Microsoft also has details on the Office application updates at http://www.microsoft.com/office/preview/en.

SharePoint Developer Center on MSDN

The SharePoint developer centre on MSDN has a good overview of the new developer related features in SharePoint 2013 including 18 training videos on new functionality relating to the changes in search, social ECM, WCM, REST, App development and OAuth.

Understanding SharePoint 2013 Apps

A big change for developers in SharePoint 2013 is the introduction of SharePoint Apps. Andrew Connell has a great overview of the new SharePoint App Model and how it fits in with other development options in his article Understanding SharePoint 2013 Apps (aka: Apps 101). While you are there be sure to register for their upcoming SharePoint 2013 webinars.

Start building apps for Office and SharePoint

To find out more about developing apps there are some great resources at the Apps for Office and SharePoint site, including code samples, details on the ‘Napa’ Office 365 Development Tools and detailed API documentation.

Sign up for an Office 365 Developer Site

The quickest way to get started building apps is to create a Office 365 Developer Site which gives you a preconfigured SharePoint 2013 Preview site. Sign up at http://msdn.microsoft.com/en-us/library/office/apps/fp179924(v=office.15) – within a few minutes you will have a shiny new SharePoint 2013 site to play with!

Download Microsoft SharePoint Server 2013 Preview

If you want to get the on-premise version you can grab it from http://technet.microsoft.com/en-US/evalcenter/hh973397.aspx?wt.mc_id=TEC_121_1_33. Eric Harlan has a good article on How to install SharePoint 2013 but this is largely the same as SharePoint 2010.

SharePoint 2013 TechCenter

To get an understanding of the architectural changes including an overview of enterprise search and authentication head over to the SharePoint 2013 for IT pros site on TechNet. This includes a bunch of videos and presentations covering the new SharePoint 2013 functionality from search (FAST functionality is now baked into the core search component), architecture, mobile, authentication (Claims is now the default and Classic mode has been deprecated), WCM (including the new Content by Search Web Part) and much more.

Top 7 developer resources for SharePoint 2013 is a post from: SharePoint Config

Office 15 is the most ambitious undertaking yet for the Office Division. With Office 15, for the first time ever, we will simultaneously update our cloud services, servers, and mobile and PC clients for Office, Office 365, Exchange, SharePoint, Lync, Project, and Visio. Quite simply, Office 15 will help people work, collaborate, and communicate smarter and faster than ever before.  

While the Technical Preview program is already full, everyone will have the opportunity to try the Office 15 public beta later this summer, and we’ll have more to share about the release then. In the meantime, I do want to thank everyone who is participating in the Technical Preview for their contributions and all our customers for their continued support.

A technical preview of the Managed Object Model Software Development Kit for SharePoint 15 was also released today and this provides some insights into what might be included in the next version of SharePoint. Some of the more interesting additions are:

The addition of a CorporateCatalog enumeration with the following values:

• StoreFront – The package is from the marketplace.
• CorporateCatalog – The package is from a corporate gallery.
• DeveloperSite – The package is from a developer site.
• ObjectModel – The package is loaded via an object model.
• RemoteObjectModel – The package is uploaded via CSOM.

New SPApp, SPAppInstance and SPAppCatalog classes. The description for the SPApp class states: “Represents an app loaded onto Microsoft SharePoint Server and ready to be installed.” which also contains a CreateAppInstance method that states “Creates an instance of an app at the specified site specified by the web parameter. The new instance can then be retrievedby using the SPAppCatalog class and using the returned ID.”

This hints at an extended deployment framework allowing more control over deployment of custom components within SharePoint. For example we also have a SPWeb.LoadAndInstallApp method that is used to upload and install an app package and a SPWeb.AppDatabaseName property.

Another potentially related addition is the SPWebApplication.IsUserLicensedForEntity method that “Checks if the currently logged in user has the proper license to access the specified entity.”

There isn’t a lot of information about what these are used for but it raises some interesting questions – is this an extension to the feature and solution model for deploying additional SharePoint functionality? Will you be able to create apps that work on Windows 8 and SharePoint 15? If you have any ideas or find any other interesting bits of information leave a note in the comments below.

SharePoint 15 object model preview is a post from: SharePoint Config

SharePoint Online Flavours

SharePoint Online is part of Office 365 which has two broad offerings; the Office 365 public cloud and Office 365 dedicated.

As the name suggests the public cloud is a shared environment so other people will be using the same servers to run their SharePoint sites. To ensure one customer doesn’t affect another customer on the same server Microsoft has had to impose many significant restrictions. For example you can’t deploy files to the file system as this could overwrite files from another customer. This was also a driving force behind sandboxed solutions – a restricted set of allowed customisations that Microsoft can guarantee won’t affect other customers in a shared environment.

There are several different licencing models for the Office 365 public cloud. The main offerings are:

• Professionals and small businesses (P plans) – these are limited to 50 users and a single site collection. There are also less features available and there is no supported upgrade to the enterprise plans (E plans).
• Medium businesses and enterprises (E plans) – these allow 300 (non-my site) site collections containing 100GB of content each. The enterprise plans also include my sites and cross-site collection search. For more details have a look at the Microsoft SharePoint Online for Enterprises Service Description.

Office 365 dedicated is aimed at 30,000+ seat deployments so unless you have a large user base this isn’t going to be an option as Microsoft will only start discussing this if you have a deployment of this size. As you are the only customer using the servers, however, you are able to deploy full trust solutions in SharePoint Online dedicated although these still need to go through Microsoft approval process before they can be deployed to the servers. The rest of this article will focus on the features and limitations of the public cloud.

Screen shots of the administration panel for the P and E plans are shown below. Note the complete lack of farm level configuration in the P plans:

P1 Administration screen (note the ‘Manage team sites’ simply takes you to the team site settings page).

E3 Administration screen (note the SharePoint Online | Manage link takes you to the following additional admin screen)

E3 SharePoint Administration Screen

E3 SharePoint Site Collection Administration – note the resource and storage quotas. Sandbox solutions are limited to consuming the available resources in the quota – if these are used up all sandbox solutions stop running.

What’s In

A broad summary of the features available in SharePoint Online is included below. More details can be found in the Microsoft SharePoint Online for Enterprises Service Description.

• My Sites
• Office Integration (2007/2010)
• SharePoint Workspace 2010 for Offline Working
• External Sharing
• Simple Public-Facing Website
• Document Libraries
• Slide & Media Libraries
• Business Taxonomies & Tagging
• Document Sets & ID’s
• Office Web Apps
• Cross-site Collection Search
• Search Refiners
• Indexing Controls
• People Search
• Phonetic Search
• Excel Services
• Access Services
• Visio Services
• SharePoint Web Services
• Forms Services
• Custom Web Parts
• Silverlight controls
• Sandboxed Solutions
• Blogs
• Wikis
• Business Connectivity Services

As you can see there are a large number of features, and Microsoft is continuing to add to this by adding features. For example support for Business Connectivity Services and the Secure Store Service was added during October and November this year. If you need to extend these capabilities then sandboxed solutions can be used.

What’s Out

At the time of writing the following features were unavailable.

• Records Center
• Information Rights Management (IRM)
• SharePoint for Internet Sites and WCM workflow and approval
• Site Variations
• PerformancePoint Services
• Power Pivot
• Full-Trust Code Solutions
• FAST Search

Development Options

There are several options for developing custom solutions for SharePoint Online. As with on-premise SharePoint deployments you can use the browser to create site columns, content types, lists, web pages and other artefacts. You can also use SharePoint designer and InfoPath to create custom workflows, enhance list forms and provide similar customisations as you can with an on-premise deployment.

If you need to write code to provide functionality such as an event receiver or a web part then you can use sandboxed solutions to create and deploy managed code assemblies. If you need to provide functionality that isn’t supported in the sandbox such as timer jobs or service applications then one option is to host this logic in an external environment such as Windows Azure and interact with SharePoint online via the client object model and/or the SharePoint web services.

Key sandbox limitations

The sandbox model has some major restrictions on what is allowed. Some of the key limitations are:

• No access to the file system
• Code restrictions:
  • GAC deployment prohibited
  • Restricted set of allowed assemblies
• No server side external calls
• No Web Application or Farm scoped functionality
• No full-trust proxy allowed in SP-O standard

Limitation #1 – No access to the file system

Without the ability to deploy files or interact with files on the file system this prevents you from using the following in SharePoint Online:

• Site definitions – These require onet.xml and webtemp.xml files deployed to the SharePoint root directory so are not available. To work around this limitation you can use the WebTemplate element that is new in SharePoint 2010 (and often overlooked). To find out more check out Vesa’s great post on SharePoint 2010 and web templates.
• User controls – Again these need to be deployed to the ControlTemplates folder in the file system. To get around this limitation you can install the Visual Studio 2010 SharePoint Power Tools as these include a Sandboxed Visual Web Part template that can be used to write a control (.ascx) file that is then compiled and deployed in your assembly, circumventing this limitation.
• Application pages – Typically used for settings or admin pages but you cannot deploy to the _layouts virtual directory as this maps to the SharePoint root LAYOUTS folder so these cannot be used. A workaround for these is to create a site page and embed a web part on this page so it appears like an application page. Wictor Wilén has a good article on this at Custom application pages in the SharePoint 2010 Sandbox. Note when embedding your web part you need to use the SPUserCodeWebPart class rather than adding your web part directly to the page.
• Branding resources – Often resources such as images and JavaScript files are deployed to the SharePoint root so these need to be deployed to a library such as the Style Library instead. Another thing to note is that all file including masterpages and page layouts provisioned via a feature are checked out when using Sandboxed Solutions. Waldek’s article Automatically publishing files provisioned with Sandboxed Solutions provides a solution for this.
• Web.config – Without the ability to change the web.config file you are prevented from many things such as creating HttpModules, adding custom authentication providers, and changing the appsettings entries. Many of these cannot be avoided but for application settings you can still use the SPWeb property bag or a SharePoint list.
• ULS logs – As you cannot write to or view entries in the ULS logs or Windows Event Logs debugging errors becomes a lot more difficult. When a web part or event handler errors in SharePoint Online there is no stack trace available and no log to check for details of what caused the error. One solution is to log to a SharePoint list and this is something I demonstrated in the SharePoint Saturday session. You need to be mindful of resource usage so the ability to switch logging on and off in production is useful here. I’ll include more details and an example solution in a later post.

Limitation #2 – Accessing external data

Code running in SharePoint online is restricted to the scope of the current site collection. You cannot make web services calls or create new SPSite objects for other site collections. Some options for interacting with external data are:

• Use client side code – This could be in the form of a Silverlight application using the Client Object Model, JavaScript running in a browser using the ECMAScript client model or using the Managed client OM such as in an Office Add-in. Wictor has a interesting article on one example of how to do this in his article SharePoint Online and External Data using JSONP.
• Business connectivity services – The BCS feature allows you to create external lists that render data from an external system so you could create a WCF service that exposes data in an external system and display this as a SharePoint list.
• Data view web part – Another simple way of getting data in is to use SharePoint designer and the data view web part. This can be used to display an RSS feed on a SharePoint page, for example. Note that you cannot use this server side so its use is fairly limited.

Limitation #3 – Code restrictions

Some important points here are that you cannot deploy solutions to the GAC so your solutions do not have full trust. This prevents components such as custom workflow solutions and timer jobs from running. You also have a very restricted set of allowed assemblies and methods within those assemblies that can be called. For example the SPSecurity namespace is not allowed so you cannot run code under the application pool account as SPSecurity.RunWithElevatedPriviledges is not allowed. The Visual Studio SharePoint Power Tools mentioned earlier help you with this limitation by compiling sandbox solutions against the allowed set of assemblies so you can identify the available methods via intellisense and at will see errors if you use these at compile time.

Another key thing to note is that you do not have full access to the Page and HttpRequest objects. When the sandboxed code runs it is executed under the SPUCWorkerProcess not the W3Wp.exe process. The SPUCWorkerProcess only contains a copy of the Page and SPWeb objects so methods that Microsoft have not implemented such as Page.ClientScript or Response.Redirect will not work.

Some good articles on this topic are (again) by Wictor and Waldek:

• Dynamically loading JavaScript from within Sandbox by Waldek
• Understanding the SharePoint 2010 Sandbox limitations by Wictor

The Sandboxed Solutions article on MSDN also has more in-depth coverage of some of these issues.

To get around some of these limitations one approach is to move your more complex application logic into an external system such as Windows Azure. The external system can then perform the procedures it needs to in a a fully trusted and fully featured environment. You might also want to store some of your data in an external system for compliance or cost reasons. Steve Fox has more information on this in his article Leveraging Windows Azure WCF Services to Connect BCS with SharePoint Online.

Limitation #4 – Deployment scope

Sandboxed solutions can only contains site collection or site/web scoped features. Additionally you don’t have full access to farm features such as search so there are features such as managed search properties that are not available in SharePoint Online. Other things that are unavailable are authentication providers and custom service applications. Again, for situations where you need to extend your SharePoint Online environment beyond the scope of the site collection you may want to consider moving this application logic elsewhere and/or consider a hybrid approach where some SharePoint content is online and some is on premise.

Resources

To find out more or get up and running I recommend using the following resources:

• Office 365 Trial – get started by setting up a 30 day trial account, or if you are a Microsoft partner sign up for an extended trial at http://www.microsoftcloudpartner.com/
• SharePoint Online for Office 365: Developer Guide
• Visual Studio 2010 SharePoint Power Tools – include the Sandboxed Visual Web Part template and compilation rules for Sandbox Solutions
• FxCop Rules for SharePoint Online – SharePoint online contains a solution validator with additional rules on top of the sandbox solution restrictions. To ensure your solution is compatible before you upload it to SharePoint online you can run these FxCop rules.

I also found the following books useful resources for understanding more about SharePoint online development.

Deploying Cloud-Based Microsoft SharePoint 2010 Solutions – good overview of Office 365. Doesn’t go into a lot of depth in terms of development but has a great high-level overview of Office 365, SharePoint Online, and high-level options for SharePoint online customisation and development.

Developing Microsoft® SharePoint® Applications Using Windows Azure- useful hands on guide to developing applications using Windows Azure and integrating these with SharePoint.

Professional SharePoint 2010 Cloud Based Solutions- I’ve haven’t read this yet as it has just been released but it appears to have lots of hands on development examples of how to integrate SharePoint with a variety of cloud services.

Developing for SharePoint Online is a post from: SharePoint Config

There are 8 different tracks and heaps of great sessions so if you can make it I’d recommend it as a way of learning more and networking with the SharePoint community.

Speaking at SharePoint Saturday UK is a post from: SharePoint Config

If there are a large number of content pages this type of tagging can help users find information as these columns can be used as filters on a list, items in a tag cloud or as search refinements.

The steps to add a managed metadata field to a publishing page are:

A) Create a managed metadata field

1. Provision a managed metadata field using type TaxonomyFieldType (or TaxonomyFieldTypeMulti to allow multiple values)
2. Configure the managed metadata column to reference an existing term set
3. Provision a hidden field of type Note
4. Configure the managed metadata column to use the hidden Note field
5. Ensure that the TaxonomyFieldAdded feature is activated on the site collection

B) Create a page layout that uses a managed metadata field

1. Create a site scoped feature for the page layout
2. Create a content type based on the ‘Page’ content type that uses the managed metadata fields
3. Create a page layout that uses the new content type
4. Create a web scoped feature for the content type association
5. Associate the content type with the pages library

As I’ve covered the process to create a managed metadata field in a previous article I won’t repeat that. Instead you can download the example solution and use the steps below to add the field to a page layout, or just use the steps below if you already have completed part A.

1. Create a site scoped feature for the page layout

In this example I’ve created two features – a site scoped feature named ‘Metadata Page’ and a web scoped feature named ‘Metadata Page Web’. The site scoped feature needs to contain the content type and page layout as these are deployed at the site collection level. It should also include a feature activation dependency on the feature(s) used in part A and the publishing infrastructure feature to ensure these features are available.

2. Create a content type based on the ‘Page’ content type that uses the managed metadata fields

Once you have deployed a managed metadata field you should create a content type that inherits from the Page content type (or one that derives from it such as the Article Page or Welcome Page). You will then want to include your managed metadata field and the hidden note field as well as any other fields you want to use in your layout. The example below adds the PublishingPageContent rich text field, the Regional Office managed metadata field and the associated hidden note field, and the Enterprise keywords field (a non-hierarchical open term set).

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

<Elements xmlns="http://schemas.microsoft.com/sharepoint/">

  <!-- Parent ContentType: Page (0x010100C568DB52D9D0A14D9B2FDCC96666E9F2007948130EC3DB064584E219954237AF39) -->

  <ContentType ID="0x010100C568DB52D9D0A14D9B2FDCC96666E9F2007948130EC3DB064584E219954237AF3900e20db8f48c7c44d0938059ab05bace32"

               Name="Metadata Page"

               Group="Custom Content Types"

               Description="My Content Type"

               Inherits="TRUE"

               Version="0">

    <FieldRefs>

      <FieldRef ID="{f55c4d88-1f2e-4ad9-aaa8-819af4ee7ee8}" Name="PublishingPageContent"/>

      <FieldRef ID="{dcb76480-4735-11e0-ab07-0800200c9a66}" Name="RegionalOffice"/>

      <FieldRef ID="{9EDAB26E-CC44-4027-AB05-CB44EA3A6F72}" Name="RegionalOfficeTaxHTField0"/>

      <FieldRef ID="{23f27201-bee3-471e-b2e7-b64fd8b7ca38}" Name="TaxKeyword" />

    </FieldRefs>

  </ContentType>

</Elements>

Note that unlike the previous post I’m not adding the TaxCatchAll or TaxCatchAllLabel fields to my content type as these are added to the list automatically when you associate the content type with the Pages list (covered in step 3). This step is only required if you are creating a list definition – more details are in the post on issues provisioning SharePoint 2010 managed metadata fields.

3. Create a page layout that uses the new content type

To create the page layout you need to create an ASPX page and a module that will deploy this to the masterpage gallery. One way of creating the ASPX page is to use the CKS:Dev Visual Studio extensions that allow you to create this by right clicking on the content type in server explorer.

Alternatively you can just create an empty module and add a standard ASPX page with the mark-up shown below:

<%@ Page language="C#" Inherits="Microsoft.SharePoint.Publishing.PublishingLayoutPage,Microsoft.SharePoint.Publishing,Version=14.0.0.0,Culture=neutral,PublicKeyToken=71e9bce111e9429c" meta:webpartpageexpansion="full" meta:progid="SharePoint.WebPartPage.Document" %>

<%@ Register Tagprefix="SharePointWebControls" Namespace="Microsoft.SharePoint.WebControls" Assembly="Microsoft.SharePoint, Version=14.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c" %>

<%@ Register Tagprefix="PublishingWebControls" Namespace="Microsoft.SharePoint.Publishing.WebControls" Assembly="Microsoft.SharePoint.Publishing, Version=14.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c" %>

<%@ Register Tagprefix="WebPartPages" Namespace="Microsoft.SharePoint.WebPartPages" Assembly="Microsoft.SharePoint, Version=14.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c" %>

<%@ Register Tagprefix="Taxonomy" Namespace="Microsoft.SharePoint.Taxonomy" Assembly="Microsoft.SharePoint.Taxonomy, Version=14.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c" %>

<asp:Content ContentPlaceholderID="PlaceHolderPageTitle" runat="server">

      <SharePointWebControls:FieldValue id="PageTitle" FieldName="Title" runat="server"/>

</asp:Content>

<asp:Content ContentPlaceholderID="PlaceHolderPageTitleInTitleArea" runat="server">

    <SharePointWebControls:FieldValue FieldName="Title" runat="server"/>

</asp:Content>

<asp:Content ContentPlaceholderID="PlaceHolderAdditionalPageHead" runat="server">

    <SharePointWebControls:CssRegistration name="<% $SPUrl:~sitecollection/Style Library/~language/Core Styles/page-layouts-21.css %>" runat="server"/>

    <PublishingWebControls:EditModePanel runat="server">

        <!-- Styles for edit mode only-->

        <SharePointWebControls:CssRegistration name="<% $SPUrl:~sitecollection/Style Library/~language/Core Styles/edit-mode-21.css %>"

            After="<% $SPUrl:~sitecollection/Style Library/~language/Core Styles/page-layouts-21.css %>" runat="server"/>

    </PublishingWebControls:EditModePanel>

    <SharePointWebControls:CssRegistration name="<% $SPUrl:~sitecollection/Style Library/~language/Core Styles/rca.css %>" runat="server"/>

</asp:Content>

<asp:Content ContentPlaceHolderId="PlaceHolderMain" runat="server">

    <h2><SharePointWebControls:TextField runat="server" FieldName="Title"/></h2>

    <p>

        <strong><PublishingWebControls:EditModePanel runat="server" PageDisplayMode="Display">Regional Office:</PublishingWebControls:EditModePanel></strong>

        <Taxonomy:TaxonomyFieldControl FieldName="RegionalOffice" InputFieldLabel="Regional Office" runat="server"></Taxonomy:TaxonomyFieldControl>

    </p>

    <p>

        <strong><PublishingWebControls:EditModePanel runat="server" PageDisplayMode="Display">Tags:</PublishingWebControls:EditModePanel></strong>

        <Taxonomy:TaxonomyFieldControl FieldName="TaxKeyword" InputFieldLabel="Tags" runat="server"></Taxonomy:TaxonomyFieldControl>

    </p>

    <div class="article-content">

        <PublishingWebControls:RichHtmlField FieldName="PublishingPageContent" HasInitialFocus="True" MinimumEditHeight="400px" runat="server"/>

    </div>

</asp:Content>

In your elements.xml file you then configure this page layout to be deployed to the masterpage gallery and use the content type you created in step 1 by using the following mark-up:

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

<Elements xmlns="http://schemas.microsoft.com/sharepoint/">

  <Module Name="PageLayouts" Url="_catalogs/masterpage" Path="PageLayouts" RootWebOnly="TRUE">

    <File Url="MetadataPageLayout.aspx" Type="GhostableInLibrary">

      <Property Name="Title" Value="Metadata Page" />

      <Property Name="ContentType" Value="$Resources:cmscore,contenttype_pagelayout_name;" />

      <Property Name="PublishingPreviewImage" Value="~SiteCollection/_catalogs/masterpage/$Resources:core,Culture;/Preview Images/DefaultPageLayout.png, ~SiteCollection/_catalogs/masterpage/$Resources:core,Culture;/Preview Images/DefaultPageLayout.png" />

      <Property Name="PublishingAssociatedContentType" Value=";#Metadata Page;#0x010100C568DB52D9D0A14D9B2FDCC96666E9F2007948130EC3DB064584E219954237AF3900e20db8f48c7c44d0938059ab05bace32;#"/>

    </File>

  </Module>

</Elements>

4. Create a web scoped feature for the content type association

At this point you should check your features to make sure the content type and page layout are associated with the Metadata Page site scoped feature. You should also create a web scoped feature to use for the following item.

5. Associate the content type with the pages library

The last step is to associate the content type with the pages library. If you miss this step then users can still create pages using your page layout but if they only have contribute permission then the managed metadata functionality is not configured properly within the pages library correctly and you get the following error:

Failed to get value of the “{0}” column from the “Managed Metadata” field type control. See details in log. Exception message: Invalid field name. {1}

To create this association create an empty module element with the following mark-up:

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

<Elements xmlns="http://schemas.microsoft.com/sharepoint/">

  <!-- Metadata page binding -->

  <ContentTypeBinding

    ContentTypeId="0x010100C568DB52D9D0A14D9B2FDCC96666E9F2007948130EC3DB064584E219954237AF3900e20db8f48c7c44d0938059ab05bace32"

    ListUrl="Pages"

  />

</Elements>

The web scoped feature that is used for this should be activated on all sites that will use the page layout you created earlier. It tells SharePoint to add the content type to the pages library as well as all associated fields and will correctly configure the managed metadata functionality when this is activated. To setup this association you might want to add this feature in your custom web templates (or site definitions) or use a FeatureSiteTemplateAssociation to associate your feature with existing site definitions such as the publishing site.

Once this is deployed you should be able to create a new page and select your page layout from the ribbon as shown below:

I’ve included the code used in the steps above in a Visual Studio 2010 project to add a managed metadata field to a publishing page layout. This builds on the previous example to create a managed metadata field so it also includes the code to create a list definition.

Adding Managed Metadata Fields to SharePoint Publishing Pages is a post from: SharePoint Config

In SharePoint 2010 these published links are managed under the user profile service application in a page called ‘Published links to Office client applications’.

We had an issue this week, however, where a client encountered the following error when trying to browse to this page.

The error message stated:

Your search encountered an error. If the problem persists, contact the portal site administrator.

There was nothing obvious in the event logs or the ULS logs about this message making it a bit of a mystery as to why it was failing.

After some investigation I found that the problem could be recreated by creating a published link that related to an audience and then deleting that audience. Yes that’s right, there is some really shoddy coding going on there and simply deleting the audience through the UI causes the entire published links screen to stop working! As you can’t see the links anymore you cannot delete the affected links. You also can’t undo the audience deletion so you are essentially stuck.

With some digging I found the values are stored in the SharedListSync table of the Profile DB relating to the user profile service application. As deleting information out of the SharePoint databases risks causing worse problems (not to mention leaving your farm in an unsupported state) I had a look at how the UI handles the deletion when the page is working and found a much better workaround.

If you add a checkbox to the page with a value that matches the ID of the link in the database you can delete the affected links. This is basically mimicking the checkboxes that would be on the page if it rendered correctly. You can then select the checkbox and use the delete button in exactly the same way SharePoint allows you to i.e. in a supported manner. This is shown below:

Note the highlighted checkbox that has been manually inserted into the DOM by editing the HTML mark up. The value=”1” will mean that the link with the ItemId of 1 in the database will be deleted. Determining the ID’s to delete does require access to the Profile DB but this can be done by taking a backup of the affected database and restoring it in a test environment if you don’t have access to live data. What you need to look for is the ItemId field in the SharedListSync table.

The values in the TargetTo column relate to an audience stored in the Profile_SearchAudienceTable. In this case we can see that the row with an ItemId of 2 has an audience so this would be the item to delete if there was a problem.

To add the checkbox to the page you can use tools such as Firebug for Firefox or the IE Developer toolbar. In either tool you just need to select the HTML tab, click edit and insert an input element with type=”checkbox” and a value matching the ItemId of the row to delete. For example to delete the row with ItemId of 2 you could insert the following.

<input type="checkbox" id="CheckedLinks1" value="2">

You need to make sure the input element is within the FORM tag of the page but it doesn’t matter where you put it. For example the screen shot below shows how you can edit the HTML using the IE developer toolbar to add the tag directly after the opening FORM element. This will place the checkbox to delete the item at the very top of the page.

If you have multiple items to remove you can add in multiple input elements, select all the items and delete them at once. Once you have deleted the links with missing audiences the screen should return to a usable state.

Error with published links to Office client applications is a post from: SharePoint Config