Background

Using an App-Only approach to automate SharePoint Online deployments avoids the need to create user accounts in Azure AD for application identities. It also ensures the application always has access to all sites, and does not first need to be added as a user. If you are using Octopus Deploy in your organisation you may want to automate SharePoint Online tasks such as deploying SPFx packages using a pipeline or create an Octopus Runbook to automate tasks such as creating a site collection based on a PnP provisioning template.

How-to

The basic steps to setup Azure AD App Only authentication for an Octopus Deploy pipeline are:

• Create an Azure App Registration and upload the Certificate – This is covered in the article Granting access via Azure AD App-Only and includes creating a certificate, Azure AD app registration, requesting API Permissions and adding the Certificate
• Create Octopus certificate variable – Using the certificate added above you can then create an Octopus certificate and assign this to an Octopus variable
• Use the Certificate in an Octopus process/runbook – Assuming you have Octopus variables as follows:
  • SharePointCertificate – certificate created above
  • ClientId – the application/client ID of the Azure AD app registration created above
  • Tenant – the name of the tenant e.g. contoso.com

You can create a deployment process that connects to SharePoint Online using the below approach:

1. Add a step to your deployment process (or Runbook) using the ‘Run a Script’ template
2. In the Inline Source Code (or reference a script that does something similar) select PowerShell and enter the following:

if(!(Get-Module -ListAvailable -Name SharePointPnPPowerShellOnline))
{
    Install-Module SharePointPnPPowerShellOnline
}

$base64cert = "#{SharePointCertificate.Pfx}"
$azureApplicationId = "#{ClientId}"
$url = "#{SharePointUrl}"
$tenant = "#{Tenant}"

$secretByte = [Convert]::FromBase64String($base64cert)
$x509Cert = new-object System.Security.Cryptography.X509Certificates.X509Certificate2
$x509Cert.Import($secretByte, "", "Exportable,PersistKeySet")

Connect-PnPOnline -Url $url -Certificate $x509Cert -ClientId $azureApplicationId -Tenant $tenant
Get-PnPWeb

You should now be able to run the Octopus process and retrieve details of the current site using the Certificate/Azure AD App Only based authentication approach. You can then extend this using the other PnP PowerShell commands to deploy SPFx packages, apply PnP Provisioning templates or any other automated deployment related tasks you wish.

You will need to give some consideration to how you secure the Certificates in production environments but Octopus does provide the ability to restrict the ability to view and/or export Certificates to authorised users, as well as allowing you to restrict access to deploy to certain environments.

The post Automating SharePoint Online deployments using Octopus Deploy appeared first on SharePoint Config.

The steps to configure this are:

1. Create a Web API project
2. Register an Azure AD (AAD) app for the Web API
3. Update the Web API project to use Azure AD authentication
4. Register an AAD app for the Swagger web site
5. Grant permissions for the Swagger AAD app to access the Web API AAD app
6. Generate a Client Secret for the Swagger AAD app
7. Enable OAuth2 implicit flow on the Swagger AAD app
8. Add Swagger to the Web API project

The example below is for a .NET Core 2.1 Web API application using Swashbuckle.AspNetCore 3.0.0:

1. Create a Web API project

The first step is to create a new Web API project either using Visual Studio or via the command line:

md AspNetCore.AzureAd.Swagger
cd AspNetCore.AzureAd.Swagger
dotnet new webapi

If you open and run the project in Visual Studio you should see the values returned from the default controller.

2. Register an Azure AD (AAD) app for the Web API

To authenticate against Azure AD you need to add an Azure AD app registration. This can be done via the Azure portal at http://portal.azure.com.

http://portal.azure.com > Azure Active Directory > App Registrations > New application registration

When the app registration is complete copy the Application ID into notepad as we will need it later

3. Update the Web API project to use Azure AD authentication

Add the following nuget package

Microsoft.AspNetCore.Authentication.AzureAD.UI

In the Startup.cs file replace the ConfigureServices method with the following:

services.AddAuthentication(AzureADDefaults.JwtBearerAuthenticationScheme)
.AddAzureADBearer(options => Configuration.Bind("AzureAd", options));

services.AddMvc(config =>
{
var policy = new AuthorizationPolicyBuilder()
.RequireAuthenticatedUser()
.Build();
config.Filters.Add(new AuthorizeFilter(policy));
}).SetCompatibilityVersion(CompatibilityVersion.Version_2_1);

This will require all requests to be authenticated.

Also in the Startup.cs file add the following to the Configure method (before the app.UseMvc() line):

app.UseAuthentication();

In appsettings.json add the following (remember to move sensitive information out of here before committing to source control e.g. use manage user secrets):

"AzureAd": {
  "Instance": "https://login.microsoftonline.com/",
  "Domain": "<Domain>",
  "TenantId": "<Directory ID>",
  "ClientId": "<Application ID>"
},
"Swagger": {
  "ClientId": "<Swagger:Application ID>",
  "ClientSecret": "<Swagger:Key Value>"
}

Copy in the Application ID from step 2 into the ClientId value and grab the domain and directory from the Azure Portal as shown below:

In the ValuesController.cs file update the Get method to include the user name so we can verify the request has been authenticated:

public ActionResult<IEnumerable<string>> Get()
{
  return new string[] { "value1", User.Identity.Name };
}

Run the application and verify it returns a 401 unauthorised error (as the browser doesn’t provide an authentication token):

4. Register an AAD app for the Swagger web site

We will now add a AAD app for the Swagger web site and grant it permission to make requests into the Web API app.

http://portal.azure.com > Azure Active Directory > App Registrations > New application registration. Enter the base URL for the project you created in step 1 followed by /swagger/oauth2-redirect.html in the Sign-on URL field.

Copy the Application ID into the Swagger:ClientId setting in appsettings.json created in step 3

Settings > Reply URLs > Ensure there is a reply URL of https://localhost:<web api port>/swagger/oauth2-redirect.html

5. Grant permissions for the Swagger AAD app to access the Web API AAD app

Settings > Required Permissions > Add > Select an API > Search for ‘Web API’ and select this from the list

Check ‘Access Web API’, click select, then click done

6. Generate a Client Secret for the Swagger AAD app

Settings > Keys > Add a Key named ‘Key 1’ set to never expire and click Save. Copy the key value into the Swagger:ClientSecret setting in appsettings.config.

7. Enable OAuth2 implicit flow on the Swagger AAD app

Edit the manifest and change oauth2AllowImplicitFlow to true

8. Add Swagger to the Web API project

Add the following nuget package swashbuckle.aspnetcore (this is tested with 3.0.0)

Add the following code to Startup.cs in the ConfigureServices method:

services.AddSwaggerGen(c =>
{
  c.SwaggerDoc("v1", new Info { Title = "My API", Version = "v1" });
  c.AddSecurityDefinition("oauth2", new OAuth2Scheme
  {
    Type = "oauth2",
    Flow = "implicit",
    AuthorizationUrl = $"https://login.microsoftonline.com/{Configuration["AzureAD:TenantId"]}/oauth2/authorize",
    Scopes = new Dictionary<string, string>
    {
      { "user_impersonation", "Access API" }
    }
  });
  c.AddSecurityRequirement(new Dictionary<string, IEnumerable<string>>
  {
    { "oauth2", new[] { "user_impersonation" } }
  });
});

Add the following code to the Configure method:

app.UseSwagger();
app.UseSwaggerUI(c =>
{
  c.OAuthClientId(Configuration["Swagger:ClientId"]);
  c.OAuthClientSecret(Configuration["Swagger:ClientSecret"]);
  c.OAuthRealm(Configuration["AzureAD:ClientId"]);
  c.OAuthAppName("My API V1");
  c.OAuthScopeSeparator(" ");
  c.OAuthAdditionalQueryStringParams(new { resource = Configuration["AzureAD:ClientId"] });
  c.SwaggerEndpoint("/swagger/v1/swagger.json", "My API V1");
});

Change the start page in Visual Studio to open swagger

Run the project and verify you can authenticate and access the API after clicking the ‘Authorize’ button.

You should now see the Bearer authentication token passed in the authorization header and the identity of the logged in user displayed in the result.

I’ve posted the full code to the following github repo:

https://github.com/aribakker/AspNetCore.AzureAd.Swagger

This article is based on information in the following articles with changes where sections are out of date:

https://broersa.github.io/dotnetcore/2018/01/17/aspnetcore-webapi-swashbuckle-swagger-oauth2-azureactivedirectory-example.html

https://blogs.msdn.microsoft.com/pratushb/2016/04/28/enable-swagger-to-authenticate-against-azure-ad/

The post Configure Swagger to authenticate against Azure AD appeared first on SharePoint Config.

The Issue

If you are behind a proxy and you try to run a npm command you will get an error similar to the one below:

npm ERR! network getaddrinfo ENOTFOUND registry.npmjs.org registry.npmjs.org:443

To configure npm to use a proxy you need to set the proxy and https-proxy config variables. This can be done as follows (where <proxy>:<port> is the url and port of your proxy server):

npm config set proxy "http://<proxy>:<port>"
npm config set https-proxy "http://<proxy>:<port>"

Now if you are behind a proxy that requires authentication you will see a slightly different error as shown below:

npm ERR! code ECONNRESET
npm ERR! network tunneling socket could not be established, statusCode=407
npm ERR! network This is most likely not a problem with npm itself
npm ERR! network and is related to network connectivity.
npm ERR! network In most cases you are behind a proxy or have bad network settings.
npm ERR! network
npm ERR! network If you are behind a proxy, please make sure that the
npm ERR! network 'proxy' config is set properly.  See: 'npm help config'

Note that the 407 HTTP error code indicates that proxy authentication is required.

Resolution

One way to resolve this issue is to use another proxy that is capable of accepting the npm requests and adding authentication headers when forwarding on the requests to the external proxy server (other ways of doing this involve including your username and password in the proxy config setting but I don’t recommend this approach in a corporate environment for security reasons).

There are several options for setting up an intermediate proxy but the one I’ve found easiest to setup is Fiddler. This approach is shown below with Fiddler adding the authentication headers when forwarding on npm requests to the proxy server that requires authentication.

The steps to configure this scenario are as follow:

1. Download and install Fiddler
2. In Fiddler select Rules > Automatically Authenticate (this is the setting that adds the NTLM authentication headers to each request)
3. Run the following npm commands to configure npm to use Fiddler as an intermediate proxy (assuming Fiddler is using the default port):

    npm config set proxy http://localhost:8888
    npm config set https-proxy http://localhost:8888

   Note that Fiddler will capture all network traffic by default. If you don’t want this behaviour you can deselect the Tools > Fiddler Options > Connections > Act as system proxy on startup option to only route npm traffic through Fiddler.

This also assumes that you have configured your proxy correctly in IE and can browse to the internet before applying the above settings.

Tip: To configure git to use the same configuration then run the following commands:

git config --global http.proxy http://localhost:8888
git config --global https.proxy http://localhost:8888

Credit goes to my colleague David Wright for pointing me in the direction of this approach.

The post Using npm behind a proxy that uses NTLM authentication appeared first on SharePoint Config.

TFS 2013 new build features

TFS 2013 includes several changes to the build process that are relevant in automating SharePoint 2013 App project builds. These features are available in both the on-prem version (Team Foundation Server 2013) and the cloud based Team Foundation Service when using Visual Studio 2013.

Simplified build process

Previous versions of TFS builds included an extremely verbose .xaml file. In TFS 2013 this has been completely rewritten and is more concise. The diagram below shows the default TFS 2012 build process template compared to the default TFS 2013 build process template.

As you can see a lot of the detail has been abstracted away. While this makes the process a lot easier to read it is a big change from previous versions so many previous build process customisation techniques no longer work. In particular the customisations in the excellent Office/SharePoint 2013 Continuous Integration with TFS 2012 project on CodePlex don’t work with this new model as the MSBuildArguments variable is no longer available. As you will see later in this article there are improvements in the build functionality that let us achieve similar results without having to customise the build process template.

Another change in TFS 2013 is that the default build process template is not stored in source control so you do not have to have a copy of the template for each project in TFS. The global default build process template is stored centrally in TFS so all projects can refer to the same instance. This removes the need for .xaml files stored in a BuildProcessTemplates folder for each TFS project if you are using the default build process.

Pre and post build scripts

TFS 2013 allows you to run batch and PowerShell scripts before and after compilation, and before and after your tests run. This allows you to perform actions such as versioning assemblies, collecting deployment files such as .app and .ps1 files into the drop folder using PowerShell rather than having to customise the build process template .xaml file. In the next part of this article I will show how to take advantage of this feature to automate the packaging of SharePoint 2013 App projects.

Building SharePoint 2013 App Projects with TFS 2013 build

The changes to the build process offer new ways to package SharePoint 2013 app projects. In particular we can use the default template without any customisations and use PowerShell to ensure our .app package and related files are copied to the drop folder.

Recap on packaging SharePoint 2013 Apps

The process to package a SharePoint 2013 App project using msbuild is detailed in the article “How to build Office developer tools projects with TFS Team Build 2012”.

For app for Office and app for SharePoint projects, you must set the following parameters:

To create package in build: /p:IsPackaging=true

To set the publish directory in the same drop output location: /p:PublishDir=<droplocation>

When your solution contains multiple app projects, set the following parameter to produce app specific publish directories: /p:AppSpecificPublishOutputs=true

As I mentioned earlier the Office/SharePoint 2013 Continuous Integration with TFS 2012 project on CodePlex includes steps to set these parameters. Unfortunately this does not work in TFS 2013 but we can take advantage of the new post build PowerShell script option to avoid having a custom build process template.

Creating a TFS 2013 Build Definition to Package SharePoint 2013 Apps

The steps to create a build definition in TFS 2013 to create a SharePoint app package are shown below:

1. Ensure you have a SharePoint 2013 App project checked into TFS 2013 (either Server or Service) and are using Visual Studio 2013.
2. In Team Explorer select Builds and click New Build Definition
   
3. In the Source Settings page enter the location of your project in TFS
   
4. In the Build Defaults page either select your on prem build controller or if you are using TF Service select the Hosted Build Controller
   
5. In the Process page select TfvcTemplate.12.xaml (TF Service) or the Default Template (TfvcTemplate.12.xaml) if you are using TF Server.
   
6. Create a PowerShell script with the following contents and save this into source control:

   # Specify file types to include    
   $FileTypes = $("*.app","*.ps1","*.zip","*.xml","*.cmd")
   
   # Specify the sub-folders to include
   $SourceSubFolders = $("*app.publish*","*deployscripts*")
   
   # If this script is not running on a build server, remind user to 
   # set environment variables so that this script can be debugged
   if(-not $Env:TF_BUILD -and -not ($Env:TF_BUILD_SOURCESDIRECTORY -and $Env:TF_BUILD_BINARIESDIRECTORY))
   {
       Write-Error "You must set the following environment variables"
       Write-Error "to test this script interactively."
       Write-Host '$Env:TF_BUILD_SOURCESDIRECTORY - For example, enter something like:'
       Write-Host '$Env:TF_BUILD_SOURCESDIRECTORY = "C:\code\FabrikamTFVC\HelloWorld"'
       Write-Host '$Env:TF_BUILD_BINARIESDIRECTORY - For example, enter something like:'
       Write-Host '$Env:TF_BUILD_BINARIESDIRECTORY = "C:\code\bin"'
       exit 1
   }
   
   # Make sure path to source code directory is available
   if (-not $Env:TF_BUILD_SOURCESDIRECTORY)
   {
       Write-Error ("TF_BUILD_SOURCESDIRECTORY environment variable is missing.")
       exit 1
   }
   elseif (-not (Test-Path $Env:TF_BUILD_SOURCESDIRECTORY))
   {
       Write-Error "TF_BUILD_SOURCESDIRECTORY does not exist: $Env:TF_BUILD_SOURCESDIRECTORY"
       exit 1
   }
   Write-Verbose "TF_BUILD_SOURCESDIRECTORY: $Env:TF_BUILD_SOURCESDIRECTORY"
   
   # Make sure path to binary output directory is available
   if (-not $Env:TF_BUILD_BINARIESDIRECTORY)
   {
       Write-Error ("TF_BUILD_BINARIESDIRECTORY environment variable is missing.")
       exit 1
   }
   if ([IO.File]::Exists($Env:TF_BUILD_BINARIESDIRECTORY))
   {
       Write-Error "Cannot create output directory."
       Write-Error "File with name $Env:TF_BUILD_BINARIESDIRECTORY already exists."
       exit 1
   }
   Write-Verbose "TF_BUILD_BINARIESDIRECTORY: $Env:TF_BUILD_BINARIESDIRECTORY"
   
   # Tell user what script is about to do
   Write-Verbose "Will look for and then gather "
   Write-Verbose "$FileTypes files from"
   Write-Verbose "$Env:TF_BUILD_SOURCESDIRECTORY and copy them to "
   Write-Verbose $Env:TF_BUILD_BINARIESDIRECTORY
   
   # Find the files
   $files = gci $Env:TF_BUILD_SOURCESDIRECTORY -recurse -include $SourceSubFolders | 
       ?{ $_.PSIsContainer } | 
       foreach { gci -Path $_.FullName -Recurse -include $FileTypes }
   if($files)
   {
       Write-Verbose "Found $files.count files:"
   
       foreach ($file in $files) {
           Write-Verbose $file.FullName 
       }
   }
   else
   {
       Write-Warning "Found no files."
   }
   
   # If binary output directory exists, make sure it is empty
   # If it does not exist, create one
   # (this happens when 'Clean workspace' build process parameter is set to True)
   if ([IO.Directory]::Exists($Env:TF_BUILD_BINARIESDIRECTORY)) 
   { 
       $DeletePath = $Env:TF_BUILD_BINARIESDIRECTORY + "\*"
       Write-Verbose "$Env:TF_BUILD_BINARIESDIRECTORY exists."
       if(-not $Disable)
       {
           Write-Verbose "Ready to delete $DeletePath"
           Remove-Item $DeletePath -recurse
           Write-Verbose "Files deleted."
       }    
   } 
   else
   { 
       Write-Verbose "$Env:TF_BUILD_BINARIESDIRECTORY does not exist."
   
       if(-not $Disable)
       {
           Write-Verbose "Ready to create it."
           [IO.Directory]::CreateDirectory($Env:TF_BUILD_BINARIESDIRECTORY) | Out-Null
           Write-Verbose "Directory created."
       }
   } 
   
   # Copy the binaries 
   Write-Verbose "Ready to copy files."
   if(-not $Disable)
   {
       foreach ($file in $files) 
       {
           Copy $file $Env:TF_BUILD_BINARIESDIRECTORY
       }
       Write-Verbose "Files copied."
   }

7. Note the script above is a modification of the script in the article Get started with some basic TFBuild scripts. It scans the source directory for app.publish and deployscripts folders and copies all .app, .ps1, .xml, .cmd, .zip files to the drop folder. You can customise this to fit your project by changing the $FileTypes and $SourceFolders parameters variables. This is effectively doing the same thing the /p:PublishDir msbuild parameter does and copies the .app package to the drop location, but is able to also include other files (e.g. .ps1 files to deploy the package).
8. On the Process page expand the Build > Advanced section and enter the following details:
   1. MSBuild arguments: /p:IsPackaging=true /p:AppSpecificPublishOutputs=true
   2. Post-build script path: <path to file created in step 6>
9. In Team Explorer under Builds right click the new build definition and select ‘Queue New Build…’
10. Once the build is complete click on the build in Team Explorer and select ‘Open Drop Folder’
11. This will either open the drop folder if you are using Team Foundation Server 2013, or open the Team Foundation Service build page if you are using the cloud version (shown below). In this case select the Download drop as zip option to download the build output.
12. If everything is set up correctly you will see an .app package with any other files you have selected to be copied to the drop folder in step 6.
13. You can then either manually deploy this to your target environment or potentially create a PowerShell script to automatically deploy this to your target environment as a post-build or post-test script argument of the build definition. If you want to do this the PowerShell scripts included in the Office/SharePoint 2013 Continuous Integration with TFS 2012 project on CodePlex provide a great starting point.

Resources

• Get started with some basic TFBuild scripts
• What’s new for Application Lifecycle Management in Visual Studio 2013
• How to build Office developer tools projects with TFS Team Build 2012
• Office/SharePoint 2013 Continuous Integration with TFS 2012
• Packaging SharePoint 2013 Apps with TFS 2012

The post Building SharePoint 2013 Apps with TFS 2013 appeared first on SharePoint Config.

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.

The post How to: Create a Simple SharePoint 2013 People Directory appeared first on 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!

The post I’m speaking at the SharePoint 2013 Evolution Conference appeared first on 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

The post SharePoint 2010 People Directory Part 3 – Sorting appeared first on 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.

The post Top 7 developer resources for SharePoint 2013 appeared first on 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.

The post SharePoint 15 object model preview appeared first on SharePoint Config.