SharePoint Roots

Show or Hide SharePoint Ribbon Tab based on User Permissions

2011-12-06T15:03:00.001+02:00

This week I wanted to figure out how to show or hide a custom developed SharePoint Ribbon Tab based on the permissions of a logged in SharePoint user.

I have a custom SharePoint 2010 Ribbon Tab with the title ‘Show or Hide Tab’ and I want to hide the tab if a current logged in user is a member of the ‘Root Visitors’ security group.

I do not want to hide the entire ribbon and I also do not want to hide only the inactive buttons. The ribbon with the ‘Documents’ and ‘Library’ tabs must be visible for all users and audience targeting must be applied to the new custom ribbon tab.

I can imagine that the requirement is quite a common one. You might want to develop a set of custom tabs which are only visible to users who are members of a specific SharePoint group.

I assume that you know how to develop a custom ribbon – if not please follow the great blog series by Chris O’Brien on Ribbon Customizations and ensure that your custom ribbon tab works before you continue with this tutorial.

I could not find a blog with an appropriate example on the web so I used a combination of a few blog posts and added my own logic.

I want to thank Chris O’Brien for his series on Ribbon Customizations and Tobias Lekman for his helpful blog post . Their contributions were extremely helpful during my research.

How it works:

I have a custom ribbon with the title ‘Show or Hide Tab’.I also have a SharePoint Group Called ‘Root Visitors’. I log in to SharePoint as a user who is not a member of this group.

I navigate to the Shared Documents library and do not see the custom ribbon tab.

Now I add the user to the security group

…and I navigate back to the Shared Documents library. Now the custom ribbon tab is visible.

Ok, so Let’s Get Started

Prerequisites (…you need the following in place before you start coding):

the ID of the Ribbon Tab which you want to hide ( I created a custom ribbon tab –see elements file contents below)
the name of the SharePoint Security Group which can see the ribbon item
jquery-1.6.2.min.js (download from http://docs.jquery.com/Downloading_jQuery)
jquery.SPServices-0.6.2.js - this is a jQuery library which abstracts SharePoint’s Web Services and makes them easier to use. It also includes functions which use the various Web Service operations to provide more useful (and cool) capabilities. It works entirely client side and requires no server install. http://spservices.codeplex.com

Development Tasks (…you will code the following):

Construct the JQuery to hide the ribbon tab
Register the JQuery to hide the ribbon tab
Verify that it all works fine

Prerequisites:

1. Get the ID of the Ribbon Tab which you want to hide:

If you have a custom ribbon tab then you can get the ID value from the Elements.xml file. In the example below the ID of my custom ribbon is ‘DemoHideRibbonTab’

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

<CustomAction

Id="DemoHideRibbonTab"

As an alternative you can use the following handy piece of JQuery to view the IDs of all the Ribbon Tabs on a page.

Copy the JQuery code below and paste it inside a Content Editor Web Part on the SharePoint library AllItems.aspx page and save the page.

<script type="text/javascript">

$("a.ms-cui-tt-a").each(function ()

{

var objTabTitle = $(this).parent().attr("id");

alert( objTabTitle );

});

</script>

When you refresh the page the JQuery will iterate through all the ribbon tabs and display their IDs.

You should see the IDs of the different ribbon tabs:

2. Get the name of the SharePoint Security Group:

The security group for which you must hide the ribbon tab must be a SharePoint group –it’s simple, you must have the name of the group.

3. Download and distribute jquery-1.6.2.min.js

The jQuery library is a single JavaScript file, containing all of its common DOM, event, effects, and Ajax functions. It can be included within a SharePoint page by linking to a local copy.

Download jquery-1.6.2.min.js from http://docs.jquery.com/Downloading_jQuery and distribute into the 14-hive of your SharePoint web-front-end server.

Example: C:\Program Files\Common Files\Microsoft Shared\Web Server Extensions\14\TEMPLATE\LAYOUTS\HideRibbonSample\Scripts\ jquery-1.6.2.min.js

4. Download and distribute jquery.SPServices-0.6.2.js

This is a jQuery library which abstracts SharePoint’s Web Services and makes them easier to use. It also includes functions which use the various Web Service operations to provide more useful (and cool) capabilities. It works entirely client side and requires no server install.

Download jquery.SPServices-0.6.2.js from http://spservices.codeplex.com and distribute into the 14-hive of your SharePoint web-front-end server.

Exanple: C:\Program Files\Common Files\Microsoft Shared\Web Server Extensions\14\TEMPLATE\LAYOUTS\HideRibbonSample\Scripts\ jquery.SPServices-0.6.2.js

Development Tasks:

1. Construct the JQuery to hide the ribbon tab

We now have all the prerequisites in place and we can start coding the JQuery which will hide the ribbon tab.

Create a new empty file and save the file to the 14-hive of your SharePoint web-front-end server.

Exanple: C:\Program Files\Common Files\Microsoft Shared\Web Server Extensions\14\TEMPLATE\LAYOUTS\HideRibbonSample\Scripts\HideRibbonSample.js

Add the following JQuery to the file.

function checkIfUserIsInGroup()

{

$(document).ready(function() { $().SPServices({

operation: "GetGroupCollectionFromUser",

userLoginName: $().SPServices.SPGetCurrentUser(),

async: false,

completefunc: function(xData, Status) {

if($(xData.responseXML).find("Group[Name='Root Visitors']").length == 1)

{

return "true";

}

else

{

HideTab();

return "false";

}

});

}

function HideTab()

{

$("a.ms-cui-tt-a").each(function ()

{

var objTabTitle = $(this).parent().attr("id");

if(objTabTitle == "DemoHideRibbonTab-title")

{

$(this).parent().hide();

}

});

}

var ribbonSelected;

function checkRibbonState() {

var id = $("li.ms-cui-tt-s").attr("id");

if (ribbonSelected != id)

{

ribbonSelected = id;

checkIfUserIsInGroup();

}

function beginCheckRibbon()

{

var checkRibbonStateInterval = setInterval("checkRibbonState()", 10);

}

$(document).ready(function ()

{

setTimeout("beginCheckRibbon()", 1000);

});

2. Register the JQuery as a custom action on the relevant ribbon tab

Open the elements.xml file in which your custom ribbon tab is defined.

You have to register the JQuery scripts in the correct sequence.

Use the ScriptLink class to register the following scripts:

1. The jquery-1.6.2.min.js script.

2. The jquery.SPServices-0.6.2.js script.

3. Your custom JQuery Hide Ribbon script.

My complete Ribbon Tab definition with the script registration is as follows:

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

<CustomAction

Id="DemoHideRibbonTab"

Location="CommandUI.Ribbon"

RegistrationId="101"

RegistrationType="List">

<CommandUIDefinition

Location="Ribbon.Tabs._children">

<Scaling

Id="DemoHideRibbonTab.Scaling">

<MaxSize

Id="DemoHideRibbonTab.OneLargeGroupMaxSize"

GroupId="DemoHideRibbonTab.OneLargeGroupExample"

Size="OneLarge"/>

</Scaling>

<Group

Id="DemoHideRibbonTab.OneLargeGroupExample"

Description="Contains custom controls"

Title="Show Message"

Sequence="55"

Template="Ribbon.Templates.OneLarge">

<Button

Id="DemoHideRibbonTab.OneLargeGroupExample.Controls.Button"

LabelText="Show Message"

Image16by16="/_layouts/images/newtargetapp16.png"

Image32by32="/_layouts/images/newtargetapp32.png"

Command="COB.Command.SayHello"

Sequence="10"

TemplateAlias="custLarge1" />

</Controls>

</Group>

</Groups>

</Tab>

</CommandUIDefinition>

<Layout

Title="OneLarge"

LayoutTitle="OneLarge">

<Row>

</Row>

</Section>

</Layout>

</GroupTemplate>

</CommandUIDefinition>

</CommandUIDefinitions>

<CommandUIHandler

Command="COB.Command.SayHello"

CommandAction="javascript:alert('Hello World');" />

</CommandUIHandlers>

</CommandUIExtension>

</CustomAction>

</Elements>

3. Verify that it works fine

Build, Package and Deploy your custom ribbon feature.

Deactivate and Activate the feature in your site and refresh the SharePoint page on which the ribbon should appear (because the registration ID of my ribbon is ‘101’ the page which I should see the ribbon tab is http://demoweb/Shared%20Documents/Forms/AllItems.aspx.

If I am a member of the ‘Root Visitors’ group then the tab is visible.

If I am not a member of the ‘Root Visitors’ group then the tab is not visible.

Enjoy!!

References:

Once again, thanks for the contributions made by members of the community.

Chris O’Brien: Ribbon Customizations

Tobias Lekman: Hiding Inactive Ribbon Commands in SharePoint 2010

European SP Conference Exceeded Expectations

2011-11-11T10:15:00.001+02:00

Wow, time flies when you're having fun!

During the past few weeks I have been on a very exciting SharePoint journey during which I travelled almost 39 000 kilometres and took part in SharePoint activities in Istanbul, Berlin and New York.

Each stop was a very different experience and each SharePoint activity offered a unique view into the SharePoint world.

The European SharePoint Conference was the highlight of this tour and exceeded all my expectations.

I have been to many conferences before and I can without a doubt say that the European SP conference was out of the ordinary.

A few highlights of the conference include the following:

· It was clear that we have moved on from the ‘Understand SharePoint’ topics to ‘Let’s provide solutions’ topics.

Conference content and vendor exhibitions were aimed at how to extend SharePoint with custom development and 3rd Party value-add features in order to provide better solutions. Strategic thinking was the order of the day and I am sure that over the course of the 3 days a significant number of industry leaders had to at some point shift their thinking from product to solution. For me as a solutions architect it is very exciting to experience how well established SharePoint is in the industry and that we are now comfortable enough to move on to a next phase in the SharePoint lifecycle.

As an example of how far we’ve come, a few years ago we had topics like ‘What’s new in SharePoint workflow development’. This year at the EUSPC 2011 we had a SharePoint Shootout session for workflow during which various workflow products were compared in order to help architects and decision makers to understand the differences between the available workflow engines.

· I experienced an instant comradeship between delegates and solid friendships were established

This is without a doubt the most important take-away from the conference. It is normally quite a challenge to ensure we make most of a conference by not allowing for the experience to end at the closing keynote. The SharePint event and other similar social get-togethers provided a great way for us to connect, have a beer (or few) and socialize. I have made friends with SharePoint comrades from around the world and appreciate that we can stay connected and exchange ideas and support one another.

· Great Presentations

The 45 minutes allocated per session was not enough time to provide a proper introduction, do a knowledge transfer and take some questions. Many delegates expressed this concern and I also battled during my presentation to stay within time.

However, the benefit of short sessions is that the audience receive high-impact and to-the-point presentations.

The speakers came from across the world to share their experiences and having 4 simultaneous tracks ensured that a wide spectrum of SharePoint topics were covered.

The presentations are available for download on the conference website.

(The presentations are immediately available to delegates and will be available to the general public after 25 November 2011)

· Exhibitors showcased valuable solutions applicable to solving real-world challenges

I am very impressed with the products which the vendors showcased. As a solution architect I always try to keep a wide range of SharePoint solution enablers in my toolbox and I am very excited to see that there is a very high industry standard and that the vendors do help us to take SharePoint further through rapid implementation of great add-ons.

· The conference was very well organized

Hats off to Helen, Mary, Declan, Tracy, and the rest of the European SharePoint team for doing a brilliant job in planning and coordinating the event. Everything went very well and I had a great time overall.

Content:

90 presentations were delivered across 4 tracks (IT DM, IT Pro, Dev and Gen). The 4 tracks provided a very rich selection of outstanding topics and at times made it difficult to choose which one of simultaneous presentations to attend. The 60 speakers came from across the globe. There was an obvious variance in the quality of the presentations but some were really good.

What I did pick up from most sessions is the fact that the speakers tend to jump in and start showing code and technical know-how without taking the time to explain to the audience how they can benefit from the feature. I believe it is extremely important for the audience to appreciate the importance and value-ad of a technical discussion before the code syntax is explained. The occasional lack of proper introductions and closing statements could be because the sessions were limited to 45 minutes each.

The presentations are available for download by the public after 25 November on the conference website.

SharePint:

AvePoint hosted a “Red-Party” on the second night of the conference but could only accommodate a limited number of people and many of us who registered for the party were disappointed to find out that we did not collect the entrance tags in time and therefore could no longer attend.

Fortunately on the Tuesday afternoon, in an effort to offer an alternative social gathering for attendees unable to attend the AvePoint party, a SharePint event was organized and co-sponsored by Qorus, Axceler, Newsgator, Metalogix, and HiSoftware. Arrangements were made, flyers were handed out, tweets were sent out, and a few hours later we enjoyed free German beer, great company and awesome music at the AM to PM Bar located in Hackescher Markt, one of Berlin’s coolest locales.

Many thanks to Qorus, Axceler, Newsgator, Metalogix, and HiSoftware for organizing and sponsoring the great evening!

Solution Enablers:

I was very impressed by the products and services showcased by the exhibitors. It is always important to understand when to develop custom solution parts vs. when to make use of 3-rd party solution enablers. And having the right mix between technical presentations and a wide range of exhibitors at the conference gives me the confidence that SharePoint solution architects will take a step back and carefully consider how a mixture of SharePoint OOB features, 3^rd-party products and custom development can solve business requirements.

Once again, think “solution” and not single product.

See the section ‘Interesting solution enablers’ at the bottom of this blog for a brief overview of a few of the products available.

Immediate Actions:

There are thousands who did not have the opportunity to attend the conference. It is our responsibility to take the conference into the workplace and I cannot wait to share the relevant knowledge with my team and local community.

I am already in touch with a number of speakers, vendors and delegates and I will trial / explore some of the products, download and research some of the presentations and use my findings to conduct at least 5 geek-talk-round-table discussions with my team in order to see how we can benefit from the conference content.

Conclusion:

Overall a very well organized conference with great structured content relevant to solving problems which we currently experience in the SharePoint industry.

A fantastic vibe between conference delegates, great relationships established and an absolute great experience.

Well done to everyone who participated and please continue with your efforts to share the knowledge and passion for SharePoint with those around you!

Interesting Solution Enablers:

Qorus Software

Qorus DocGeneration works with Microsoft SharePoint 2007 / 2010 and Microsoft Word to dramatically reduce the time and effort required to generate complex, customized documents while improving quality, consistency and effectiveness. http://www.qorusdocs.com/

SurfRay – Ontolica Search

Ontolica Search Preview allows you to preview and read documents in any format directly in SharePoint search results, with hit highlighting, and navigation to the most relevant pages in your documents . This reduces search costs and increases user adoption dramatically. http://www.surfray.com/

NewsGator

NewsGator solutions help you overcome business challenges by providing an integrated, behind-the-firewall, social computing platform that supports collaboration, facilitates communication, and improves worker knowledge. http://www.newsgator.com/

Kaldeera

KAF is a tool that allows you to modify the standard SharePoint® forms and create powerful web form-based applications. Hide fields, display "uneditable" fields, grouping and display the information in a more intuitive way adding static text, images, Web Parts, etc. http://www.kaldeera.com

GetOrganized

In brief GetOrganized is a user friendly standard product which organizes e-mails, documents, tasks etc. in a relevant context in order to optimize collaboration and business processes in your company in a simple and efficient way. http://en.getorganized.net

Bamboo Solutions

Bamboo® Solutions provides technologies that augment the SharePoint platform, and more than 60 products that provide a broad range of enhanced capabilities and solutions that maximize the value of SharePoint deployments. http://bamboosolutions.com

MetaLogix

Provides comprehensive content lifecycle management solutions that allow you to easily move data, reduce compliance risk, cut the cost of discovery, reduce storage and simplify management of Microsoft content, whether it’s on-premises or in the cloud. http://www.metalogix.com

Axceler

Axceler provides SharePoint solutions that help the SharePoint management team get the most out of their platform and address the most pressing SharePoint challenges facing enterprises today. Solutions include SharePoint Governance, SharePoint Administration, SharePoint Migration, SharePoint Security, SharePoint Reporting and SharePoint Visibility. http://www.axceler.com

HiSoftware

HiSoftware provides content-aware compliance solutions for both Web and SharePoint® environments that detect private or confidential data and report on violations to ensure compliance with regulatory and other internal policies. http://www.hisoftware.com

Authentication Methods for SP2010 Client OM

2011-06-28T16:04:00.001+02:00

On 25 June 2011 I presented a session at SharePoint Saturday India on the topic of the ‘SharePoint 2010 Client Object Model’. One of the questions which were asked was around the various authentication methods when using the Client Object model.
This short post will describe the authentication methods available when using the SharePoint 2010 .Net Managed Client Object Model.

The 3 Object Models with their available authentication methods are:

.NET Client Object model
- The default is to authenticate users via their current Windows credentials (NTLM and Kerberos).
- Possible for you to define other authentication methods like Anonymous or Forms Authentication.
Silverlight Client Object model
- Default is to authenticate users via their current Windows credentials (NTLM and Kerberos).
- It is possible for you to define other authentication methods like Forms Authentication.
- It is not possible to use the Silverlight client object model with anonymous authentication.
ECMA Script Client Object model
- No need for additional authentication as JavaScript already runs in an authenticated page.

Authentication Methods when using the .Net Client Object Model

The Microsoft.SharePoint.Client namespace provides a ClientAuthenticationMode enumerator.The members are:

Default: Represents the default authentication mode.
FormsAuthentication: Represents ASP.NET forms authentication mode.
Anonymous: Represents anonymous authentication mode.

So in order to specify the authentication type you will have something like:

//Create a client context for my site which uses Forms Authentication
ClientContext clientContext = new ClientContext("http://ltp-21:31890");
//Set the AuthenticationMode
clientContext.AuthenticationMode = ClientAuthenticationMode.FormsAuthentication;

If you use Forms Authentication you will have to set properties for an instance of FormsAuthenticationLoginInfo class and assign that to the client context (see example below).

Note:
All the examples below are based on creating a .Net Windows Console Application. Remember to please add references to:
Microsoft.SharePoint.Client: C:\Program Files\Common Files\Microsoft Shared\Web Server Extensions\14\ISAPI\Microsoft.SharePoint.Client.dll
Microsoft.SharePoint.Client.Runtime: C:\Program Files\Common Files\Microsoft Shared\Web Server Extensions\14\ISAPI\Microsoft.SharePoint.Client.Runtime.dll

The code for all three examples will:

Create a client context for my site which uses a specific authentication method.
Instruct the client context that I want to load the sub-site.
Get the title of the site and write it to console.

Default Authentication:
In this example the client object model will connect through using the current Windows credentials (NTLM / Kerberos).
Because the default authentication method for client object model is NTLM / Kerberos we do not explicitly need to specify an authentication method.
Remember to replace the URL of the site with that of your environment.
In my environment the URL http://ltp-21:13111 points to site configured for NTLM authentication.

using System;
using Microsoft.SharePoint.Client;
namespace StdAuthSample
{
class Program
{
static void Main(string[] args)
{
ClientContext clientContext = new ClientContext("http://ltp-21:13111");
Web site = clientContext.Web;
clientContext.Load(site);
clientContext.ExecuteQuery();
Console.WriteLine("Title: {0}", site.Title);
}
}
}

Forms Authentication:
In this example the client object model will connect through using Forms Authentication.
You have to explicitly set the authentication method to Forms Authentication by using the clientContext.AuthenticationMode.
Then you also have to specify the Authentication Login Info by creating an instance of FormsAuthenticationLoginInfo and setting the new clientContext.FormsAuthenticationLoginInfo to that of your FormsAuthenticationLoginInfo object.
Remember to replace the URL of the site with that of your environment.
In my environment the URL http://ltp-21:31890 points to a site configured for Forms Authentication.

ClientContext clientContext = new ClientContext("http://ltp-21:31890");
//Set the AuthenticationMode
clientContext.AuthenticationMode = ClientAuthenticationMode.FormsAuthentication;
//Instantiate a FormsAuthenticationLoginInfo object.
FormsAuthenticationLoginInfo formsAuthInfo = new
FormsAuthenticationLoginInfo("MyFormsTestUser", "MyUserPassword!2");
//Specify the login details using the FormsAuthenticationLoginInfo object.
clientContext.FormsAuthenticationLoginInfo = formsAuthInfo;
Web site = clientContext.Web;
clientContext.Load(site);
clientContext.ExecuteQuery();
Console.WriteLine("Title: {0}", site.Title);

Anonymous Authentication:
In this example the client object model will connect through using Anonymous Authentication.
You have to explicitly set the authentication method to Anonymous Authentication by using the clientContext.AuthenticationMode.
Remember to replace the URL of the site with that of your environment.
In my environment the URL http://ltp-21:12381 points to a site configured for Anonymous Authentication.

ClientContext clientContext = new ClientContext("http://ltp-21:12381");
//Set the AuthenticationMode
clientContext.AuthenticationMode = ClientAuthenticationMode.Anonymous;
Web site = clientContext.Web;
clientContext.Load(site);
clientContext.ExecuteQuery();
Console.WriteLine("Title: {0}", site.Title);

I hope this will give you a simple but complete overview of the 3 authentication methods available when using the .Net Managed SharePoint 2010 Client Object Model.
Enjoy!!

Improve SharePoint Search Relevance

2011-05-20T16:30:00.001+02:00

Introduction:

I recently developed a SharePoint 2010 solution which includes an advanced search web part which allows the users to perform enterprise searches and view the returned results in a graphical rich representation.

As an architect I want to ensure that the search results that are returned to the user match what the user wanted to find and that the results that are returned on the first page are the most relevant, so the user does not have to look through several pages of results to find the best matches for their search. This is called Search Relevancy.

It is very important to realize the difference between Sorting and Ranking. In my own words I would describe Sorting as the process or arranging objects according to a specific attribute of the item. An example would be the books in a library.

Ranking is where an item takes precedence over other items based on a combination of attributes. Examples of this would be how tools in a workshop are arranged, how equipment is arranged in an E.R. room, how individuals are ranked based on the role they play in the military, or even how food items are arranged in the supermarket. One realize from these examples that there is no single property which can be used to determine the ranking of such items and that Ranking is based on the importance an item has in a given situation.

The Role of the SharePoint Architect:

Architects and developers place a lot of focus during development to ensure that search engine works well. Performance and Accuracy of search results are normally the main focus point.

Providing a comprehensive search solution requires that the architect considers the search experience from the end-user point of view.

The end-user is not really concerned about what happens on the server and will most likely not appreciate the effort which goes into building robust search engines.

Management spend up to 27% of their time looking for information and when using the Search functionality in your SharePoint solution only one question will be asked; “Did I find what I was searching for on the first page of the results?” If the item the user searched for is not part of the first 10 search result items then then user will most likely believe the item does not exist in the system.

The SharePoint Search Ranking Model:

Relevance is about how closely the search results that are returned to the user match what the user wanted to find.

SharePoint uses a formula to determine which items are most relevant but the end-users have a different view on what should be considered the most relevant items. Even different users who use the same solution might have different opinions about this. (To be honest I can relate to this as I will sometimes at home arrange our DVD collection in a particular order and another family member would prefer a completely different order)

As an example when the user performs a search using the keyword ‘Demo’ the SP Search Engine returns the items in the following order:

SharePoint evaluates all properties and even the contents of the documents returned in the search results and used a complex algorithm to determine which items are most relevant and which items are least relevant.

Users are not interested in algorithms and might not even consider the fact that the search engine also takes into calculation less obvious dynamics like “Click Distance”, “Document Location (URL Depth)”, “Document Popularity”, “Language Detection”, “File Type”, etc. In actual fact the algorithm is very complex and it is unfortunate that very few end users appreciate at how clever the search engine is.

Some users might feel that the search results should be ranked in a way so that the Title of the item is considered the most important determining factor.

In this example we executed the same search we tested earlier but because a different preference of ranking were specified two of the result items were allocated a lower ranking order and items where the Title field are closer to the search criteria used moved up in the ranking.

There might even be a requirement to rank the search results based on a custom field like ‘Client Name’. You can see from the same search results below the item where the search criteria was not found as part of the ‘Client Name field moved down in the ranking order and items which contains the search criteria in the ‘Client Name’ field moved up in the rank.

SharePoint Enterprise Search includes a ranking engine developed in collaboration with Microsoft Research. It is specifically tuned for the unique requirements of searching enterprise content.

The great news is that it is possible for IT Professionals to customize the way SharePoint rank search results. This can be done through creating a custom model (ranking model) and instructing SharePoint to use the custom model in a particular area of the solution or even to set the new ranking model as the default for SharePoint Search.

This article will provide you with the necessary background SharePoint Ranking Models and will guide you through the process of creating and implementing your own custom ranking models.

Let’s Get Started!!

Structure

As a developer I used to hate this part of an article… the mumbo-jumbo theory stuff which can be very boring, but believe me, if you really want to become one of the best SharePoint professional you have to consider the ground-rules, even if they are not always applicable to the immediate problem which you are trying to solve. So here we go….

Ranking Model are based on a XML schema which contains an unique identifier, name, description and specifics of the components as part of the formula when calculating numeric scores which indicate which search results are more relevant than others. (For those who are interested in the formula please research the BM25 rating model)

The formula to calculate relevance uses two areas of ranking called Static and Dynamic ranking.

Dynamic Ranking (query-dependent ranking) is where the property values or content of an item affects the ranking score. As example the ‘Title’ field can be evaluated against the search criteria and the more important we consider the field to be, the higher the ranking score will be for items where the value in the ‘Title’ field have a closer match to the search criteria.

Static Ranking (query-independent ranking) is where the content or property values of an item do not determine the ranking of the item.

Dynamic Ranking contains the following components:

Property Weighting is used to assign a weighting to a property so that they are weighted more heavily in the relevance calculation. Configure this setting to a value between 1 and 75.
Property Length Normalization – because properties of an item vary in length, evaluation of the values cannot be treated equally and we need to adjust the rank of a content item, based on the length of the property, and the length normalization setting. This only applies to properties that contain text.The range of possible values for this setting is 0 to 1. For long text-managed properties, you usually want to set this to a value near to 0.7, which is the approximate setting for the body property. For properties that contain a small amount of text use a value of approximately 0.5.
Title Extraction - only performed on Microsoft Office files. In scenarios where the ‘Title’ field of an Office file does not accurately reflect the contents of the item (example when a title of a file is ‘Presentation 1’ or ‘Document 1’), Enterprise Search detects another candidate for title within the body of the content item, and includes this value with the actual title when calculating relevance. (I think this is really cool!)

Static Ranking contains the following components:

Click Distance is the number of links between a content item and an "expert" page linking to the content item. The more links that the crawler must travel from an authoritative page to the content item, the lower the relevance score. If there are multiple paths to a content item, relevance is calculated based on the shortest path.
URL Depth refers to how many levels deep within a site the content item is found. The level is determined by reviewing the number of slash ("/") characters in the URL; the greater the number of slash characters in the URL path, the deeper the URL is for that content item. A large URL depth number can lower the relevance of that content.
Automatic Language Detection determines the user's language based on "Accept-Language" headers from the browser they are using and content that is retrieved in the user's language is considered more relevant than content in other languages, with the exception of English language content.
File Type Biasing - in most search scenarios, certain file types are more relevant than others. For example, HTML pages and Word documents are usually more relevant to a user's search than an Excel spread sheet or a plain text file.

Tutorial (…the exciting part)

What you need:

SharePoint Central Administration
SharePoint Site with a document library
5 Sample documents (no other content in site)
A Search Scope to the particular SharePoint site which you want to search in.
Understanding of Manage Metadata Properties (only if you want to search on custom site columns.
PowerShell
Utility or source code to test our ranking model

Test Harness:

Before we build a new custom ranking model let us first develop a small utility to help us test our ranking model. (You can also export the standard SharePoint Core Search Results Web Part and modify the xml to specify the ranking model to use, but in most cases I prefer to use a test harness instead of making changes to SharePoint until I have finished quality assurance of my custom code).

Create a new Visual Studio console application and add the following code to your Program.cs class:

using System;
using System.Collections.Generic;
using Microsoft.SharePoint;
using System.Diagnostics;
using Microsoft.Office.Server.Search.Query;

namespace SP2010SearchSample
{
class Program
{
static void Main(string[] args)
{
SPSite objSite = new SPSite("http://ltp-21:14111"); //Replace with yours
SPWeb objTargetWeb = objSite.OpenWeb("/");
ResultType resultType = ResultType.RelevantResults;
//VERY IMPORTANT TO USE DEFAULTPROPERTIES instead of *
//Replace 'SPSearchDemoSearchScope' with your Search Scope Name
string strQuery = "SELECT RANK, Filename, Title, FROM SCOPE() WHERE
FREETEXT(DefaultProperties, '*demo* ') AND \"SCOPE\" = 'SPSearchDemoSearchScope' ORDER BY \"Rank\" DESC ";
FullTextSqlQuery fullTextSqlQuery = new FullTextSqlQuery(objSite);
fullTextSqlQuery.QueryText = strQuery;
fullTextSqlQuery.ResultTypes = resultType;
//This is where we will later specify the custom ranking model to use.
//fullTextSqlQuery.RankingModelId = "";
ResultTableCollection resultTableCollection = fullTextSqlQuery.Execute();
ResultTable resultTable = resultTableCollection[resultType];
while (resultTable.Read())
{
Console.WriteLine("Rank:" + resultTable["RANK"].ToString() + " Title:" + resultTable["TITLE"].ToString());
}
}
}
}

Please note the following:

Your namespace will be different.
Replace http://ltp-21:14111 with your site URL
Replace 'SPSearchDemoSearchScope' with your Search Scope name.
I included a placeholder (//fullTextSqlQuery.RankingModelId = "";) to later specify our custom ranking model to use.

Compile the application and run it. If there are no problems you should see the search results returned and ranked using the default SharePoint Ranking model.

You can also refer to: Best Practices: Writing SQL Syntax Queries for Relevant Results in Enterprise Search

Now that we have a test harness to use for testing different ranking models we can proceed to Build and implement a new custom ranking model

We need to following values in order to construct our xml:

Item	Description	How to find value
Name	The name of your custom ranking model	Any value you want to use.
Id	The unique identifier for the ranking model	Use GUIDGen Tool to create a new GUID.
Description	A description of your ranking model	Any text you want to use.
One or more queryDependentFeatures
pid	The property ID of a managed property in the search schema.	Run the following PowerShell command to export all the PIDs to a text file: Get-SPEnterpriseSearchServiceApplication \| Get-SPEnterpriseSearchMetadataManagedProperty >> C:\PID.txt
name	The name of a managed property	Run the following PowerShell command to export all the Property names to a text file: Get-SPEnterpriseSearchServiceApplication \| Get-SPEnterpriseSearchMetadataManagedProperty >> C:\PID.txt
weight	The weight setting for a managed property.	Any value between 0 and infinity. If the value is 0 the property is ignored. Normally the value is between 1 and 75.

The xml schema for a ranking model is structured in the following way:

The following link describes the different elements in the XML: http://msdn.microsoft.com/en-us/library/ee558793.aspx

So, in order to create a new ranking model, open a xml editor and use the following example:

<?xml version="1.0" encoding="utf-8"?>
<rankingModel
name="DemoRankingModel"
id="302A9E0E-F8B9-4b21-8180-C327ECCBBA94"
description="Demo Custom Ranking Model"
xmlns="http://schemas.microsoft.com/office/2009/rankingModel">
<queryDependentFeatures>
<queryDependentFeature pid="56" name="Filename" weight="75" lengthNormalization="10" />
<queryDependentFeature pid="2" name="Title" weight="25" lengthNormalization="10" />
</queryDependentFeatures>
</rankingModel>

Next, run the following PowerShell command to upload your new custom ranking model:
Get-SPEnterpriseSearchServiceApplication | New-SPEnterpriseSearchRankingModel –RankingModelXML ‘{your xml pasted as a string}’

Using the new Ranking Model:
There are two ways of using the custom ranking model
1. Search logic implemented through the object model (shown in this tutorial)
2. Extending the Core Results Web Part
http://msdn.microsoft.com/en-us/sp2010devtrainingcourse_extendingsharepointsearchlab_topic4#_Toc280092619

You can use the test harness described in the beginning of this tutorial to test your new ranking model. To do that, uncomment the following line and supply the GUID of your new ranking model:

//This is where we will later specify the custom ranking model to use.
fullTextSqlQuery.RankingModelId = "302A9E0E-F8B9-4b21-8180-C327ECCBBA94";
//remember to replace the ID value with the GUID of your ranking model

You will notice a change in the way your test harness return the results.

The following diagram shows how your code and the SharePoint Foundation will use your custom Ranking Model to provide different results:

Additional PowerShell Commands:

List all of the Managed Properties in SharePoint Search:
Get-SPEnterpriseSearchServiceApplication | Get-SPEnterpriseSearchMetadataManagedProperty >> C:\PID.txt

Add a new ranking model to SharePoint :
Get-SPEnterpriseSearchServiceApplication | New-SPEnterpriseSearchRankingModel –RankingModelXML ‘{Ranking model XML PASTED AS A STRING}’

List the ranking models:
Get-SPEnterpriseSearchServiceApplication|Get-SPEnterpriseSearchRankingModel

Delete a ranking model:
Remove-SPEnterpriseSearchRankingModel -Identity ‘xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx’ -SearchApplication Get-SPEnterpriseSearchServiceApplication

I hope that you will make full use of all the SharePoint capabilities like custom ranking models to unlock your full potential to providing world-class SharePoint solutions.

Enjoy !

Upcoming Events

2011-05-20T13:58:00.001+02:00

Very few things in life are more rewarding for me than to see that I have made a positive impact on the life of one or more individuals through my technical- and motivational contributions to the community.
This month I have been very fortunate to be invited to a number of local as well as international events. I hope to see you at the following events where I will speak on various SharePoint topics:

24 May 2011 – Microsoft Dev Days - Cape Town (community slot)
Improve SharePoint Search Relevance through Custom Ranking Models
When searching for content we want a search engine to put the most relevant content at the top of the results page. SharePoint employ different ranking models to compute what content item is more relevant than another content item. In this session we will explore how you can use PowerShell and Visual Studio to build SharePoint Custom Ranking models in order control how SharePoint determine the relevancy and order of search result items.
URL: http://www.microsoft.com/southafrica/devdays/

31 May 2011 – Information Worker Community – Cape Town
SharePoint 2010 Sandboxed Solutions
In this session we will take a look at SharePoint Sandboxed solutions, understanding what they are, why they were introduced and best practices for building one. We will also advise Farm Administrators on the tools & techniques available to manage user solutions and partially trusted code in a SharePoint farm.
URL: www.informationworker.co.za

25 June 2011 – SharePoint Saturday India – Online Event
Understanding the SP2010 Managed Client Object Model
In this session we will take a look at the SharePoint2010 Managed Client Object Model.
We will present an overview of what the Client Side Object Model is, why it was introduced, what are the best practices for using it and lessons learned from the field.
URL: www.sharepointsaturday.org/india

18 October 2011 – European SharePoint Conference – Berlin
A Developer’s mind-shift from Sp2007 to Sp2010.
In this session we will discuss the best approach for a SharePoint 2007 developer to make the transition to SharePoint 2010 development. We will introduce new advancements in the SharePoint 2010 platform as well as how SharePoint 2010 is now integrated with Visual Studio 2010. The outcome of this session is to provide the developer with a roadmap for making the transition from SharePoint 2007 development to SharePoint 2010 development with Visual Studio 2010, SharePoint Designer 2010, PowerShell and Codeplex solutions for SharePoint 2010.
URL: http://www.sharepointeurope.com

I sincerely hope to see you at the events!
In case you miss any of the events, please keep an eye on this blog site as I will post all my presentations in the form of detailed whitepapers.

Enjoy!

Resolve SharePoint Errors caused by SQL Express

2011-04-13T17:15:00.001+02:00

Today I tested my bulk import tool as part of a data migration. The code in the custom developed tool is straight-forward and must move list items and documents from over 600 SharePoint 2007 sites into a single SharePoint 2010 site.

Soon after starting my tests I ran into SharePoint foundation problems.

Problem:

Whenever the code attempts to upload a file into SharePoint I got the following error:

The URL 'Document_2011/0000000zzz/Test Document.docx' is invalid.

It may refer to a nonexistent file or folder, or refer to a valid file or folder that is not in the current Web. Troubleshoot issues with Microsoft SharePoint Foundation.

I then tried to manually delete a file from the SharePoint site and received the following error:

The server has encountered the following error(s):

ExampleFile.pdf

Exception from HRESULT: 0x80131904

When I try to delete the entire document library I receive the following error:

Exception from HRESULT: 0x80131904

Troubleshoot issues with Microsoft SharePoint Foundation.

Investigation:

I investigated the SharePoint content database.

In Central Admin, go to Application Management and then to Manage Content Databases.

You can select the web application and view the details of the associated content database.

I then logged into SQL Server Management Studio and confirmed that the content database ran out of space. As you can see from the screenshot below, the database size is 4138.19 MB and there is only 0.13 MB free space. (ensure to log into the correct instance of SQL in order to see the content databases)

Cause:

When SharePoint 2010 is installed the user can select to perform a ‘Basic’ or default installation.

Selecting a ‘Basic’ installation is a big mistake, but unfortunately guys who are new to SharePoint might not be aware of the pitfalls.

When you installed SharePoint 2007 as basic, the installation used the Windows Internal Database, a version of SQL Express with no size limit, but in SharePoint 2010 the installation will be done on SQL Express which has a 4GB size limit.

SQL Express 2008 R2 has a 10GB size limit, but it might still not be enough.

This was exactly my problem –SharePoint was installed as a ‘Basic’ installation on a test environment and I was trying to upload a large number of files – around 5.3GB in total size. Once I reached the limit of 4GB SharePoint could not perform any operations on the database which requires more space.

Remember that even if you try to delete items from SharePoint, they are only moved to the recycle-bin so the used database space does not become available immediately.

Solution:

There are two ways to solve this:

1-You can either upgrade from SQL Express to SQL Server,

2- Implement EBS (External Blob Store - move the BLOB items out of the database onto a file system. For more information on this please see http://msdn.microsoft.com/en-us/library/bb802812.aspx )

I decided to go with option #1-Upgrade my SQL Instance from SQL Express to SQL Server 2008 R2. The better architecture would be to go with EBS but I wanted to explore the database upgrade and do the EBS later.

Upgrade Steps:

1-Close SharePoint and Close SQL Server Management Studio.

2-Open Command Prompt and run the following command from the location where the SQL Server installation files are available to start the installation (upgrade) of SQL Server R2.

Setup.exe SKUUPGRADE=1

3-Proceed through the installation wizard and on the Installation window click on ‘Upgrade from SQL Server 2000, SQL Server 2005 or SQL Server 2008.

4-Proceed through the wizard until you get to the ‘Select Instance’ page.

Remember when we inspected our database details in Central Admin we were able to see the SQL instance:

5-Now, in the SQL Upgrade wizard you have to select the same instance. You can see from the screenshot below that my “SHAREPOINT” instance was originally installed as ‘Express’ so this is the one which I have to select to be upgraded to SQL Server 2008 R2.

6-Click on Next and continue through the wizard….When you get to the “Instance Configuration” page pay careful attention to ensure that all the details are correct.

8-Click on Next and proceed through all the pages to complete the all the installation wizard steps.

9-Once completed review the results to confirm that the upgrade was successful.

10-After this perform an IISReset.

Verify Success:

I viewed the properties of my upgraded database and immediately noticed that the space available was increased from 0.13MB to 1.02MB.

Also, after this I was able to add more content to SharePoint and grow the database size beyond 4GB..

Enjoy!!

Thanks to Todd Klindt - http://www.toddklindt.com/blog/Lists/Posts/Post.aspx?ID=55 for his contributions.

Import and Publish Nintex Workflows programmatically

2011-03-17T13:15:00.002+02:00

I recently developed a SharePoint solution which requires that 3 Nintex 2010 workflows are published on 13 document libraries in 22 SharePoint sites. I developed the Nintex workflows on a single library in one site and gave it to the test team to perform quality assurance. Now that I know the workflows are working well, we are ready to export them and upload and publish them to a much larger test environment. This will require that we import and publish 3 workflows x 13 libraries x 22 sites …thus a repetitive 858 manual tasks… there is no way that we will do this manually, so I took a little time to develop a tool which will programmatically import and publish workflows.
I found that it really is easy to utilise the Nintex web services to manage workflows.
In this tutorial I will give you a high level overview of how to use code to upload / import .nwf files to a target SharePoint site thereby automating the process as much as possible. This approach will help you to move workflows between development-, test- and production environments.
What we want to achieve:
I developed a simple tool which allows you to select one or more exported workflow files as source and then specify the target environment to which the workflows must be imported and published.

You need the following:
1. A few working Nintex workflows exported to local .nwf files.
2. A target SharePoint site with document libraries or lists which you can use as target to import and publish the workflows to.
3. Nintex Web Services must be accessible (installed with Nintex).
Preparation:
1. .NWF Files: To create a few workflows to test with I created a few really simple workflows like the one below which just update a single field on the list / library. I then saved the workflow, published it and tested it. After I have confirmation that the workflow works well I proceeded to export the workflow as a local .nwf file. Remember that this must be done in a SharePoint site which is different than your target site or you have to delete the workflows from the site before you test the import code.

2. Target SharePoint site: Your target SharePoint site must have Nintex Workflow installed and configured. You can go to your test target library and from the ribbon verify that you have access to create or manage Nintex workflows:

3. Nintex Web Services: You should be able to browse to the Nintex Workflow web services.
These web services are included as part of the Nintex Workflow out of the box installation.
The URL will be <SP Web App URL></_vti_bin/nintexworkflow/workflow.asmx>
Example: My target site is in the following web application http://ltp-21:17819/ so the URL which I will use to access the Nintex Workflow web services will be:
http://ltp-21:17819/_vti_bin/nintexworkflow/workflow.asmx
You should be able to use Internet Explorer to navigate to the web service URL.

Let’s Write the Code:
Please note that in order to simplify the tutorial I will only show the code which is required to import and publish the workflows.
I therefore assume that you will be able to develop the additional code which you will need to make a tool similar to the screenshot at the beginning of this post fully functional. If you are interested in any other bits of the code for the complete tool please leave a comment and I will gladly send it to you.
1. Create a new Visual Studio Windows Forms Application.
2. Because we target SharePoint 2010 remember to set your platform target to 64 bit:

3. Add a web service reference to the Nintex Workflow web service:
Remember the URL of the Nintex Workflow web service is in the form
<SP Web App URL></_vti_bin/nintexworkflow/workflow.asmx>
Example: My target site is in the following web application http://ltp-21:17819/ so the URL which I will use to access the Nintex Workflow web services will be:
http://ltp-21:17819/_vti_bin/nintexworkflow/workflow.asmx
I used NintexWorkflowService as the web reference name

4. Add a new button named cmdImportWorkflow onto Form1:

5. Add the following code to the button click event:

try
{
NintexWorkflowService.NintexWorkflowWS objWFService = new NintexWorkflowService.NintexWorkflowWS();

objWFService.Url = "http://ltp-21:17819/MyNintexSite/_vti_bin/nintexworkflow/workflow.asmx";

objWFService.Credentials = System.Net.CredentialCache.DefaultCredentials;

byte[] arrWorkflowFile = System.IO.File.ReadAllBytes(@"E:\WorkflowsToImport\UpdateTitlewithTime.nwf");

objWFService.PublishFromNWF(arrWorkflowFile, "MyDocs", "My Imported Workflow", true);

}
catch (Exception exception)
{
MessageBox.Show("An error occured while trying to publish the workflows: " + exception.Message);
}

MessageBox.Show("Done");

Let’s Analyse the code:
1. Instantiate the Nintex Workflows web method:

NintexWorkflowService.NintexWorkflowWS objWFService = new NintexWorkflowService.NintexWorkflowWS();

2. Ensure the web method will execute against the correct target URL:

objWFService.Url = "http://ltp-21:17819/MyNintexSite/_vti_bin/nintexworkflow/workflow.asmx";

This URL must be the full URL to the target SharePoint site followed by “/_vti_bin/nintexworkflow/workflow.asmx”.

Please ensure that you replace the first part of the URL with that of your target environment.

3. Set the credentials for the web service:

objWFService.Credentials = System.Net.CredentialCache.DefaultCredentials;

4. Read the Nintex workflow file (.nwf) into a byte array:

byte[] arrWorkflowFile = System.IO.File.ReadAllBytes(@"E:\WorkflowsToImport\UpdateTitlewithTime.nwf");

This is the workflow which we exported earlier to a local file.

5. Call the web method to import and publish the workflow file.

objWFService.PublishFromNWF(arrWorkflowFile, "MyDocs", "My Imported Workflow", true);

The parameters are:

1. arrWorkflowFile: Byte Array of the workflow file to be imported.

2. listName: The name of the target list / library.

3. workflowName: The name which will be assigned to the new imported workflow.

4. saveIfCannotPublish: Flag to indicate whether the workflow must be saved if it cannot be published.

Verify Success:
Run the code and step through each line to ensure there are no exceptions.
After successful execution open the target SharePoint site and the target document library / list.
Go to Manage Nintex Workflows and verify that the workflow was successfully imported and published – you should see the new published workflow.

Conclusion:
As you can see from the sample code it is really easy to automate the import and publishing of Nintex 2010 workflows to SharePoint 2010. You might come across a few exceptions if your environment does not allow certain workflow actions or if dependencies (like list or field lookups in workflows) are not in place in the target environment.
You can now use the very basic sample code to develop a tool like the one I illustrate at the top of this post to automate workflow upload & publishing and hopefully save your system administrator hours of manual configuration.
Enjoy !!

Nintex Workflow 2010 ‘Task Reminder’ Bug & Fix

2011-02-11T09:58:00.002+02:00

This morning I came across the following error while trying to publish a Nintex 2010 workflow which contains a ‘Task Reminder’ workflow action.

Background:

I have a SharePoint 2010 MOSS environment. I create a new Nintex 2010 Workflow which I can save and publish without problems.

Then I add a ‘Task Reminder’ action

And when I publish the workflow I get the following error:

Cause:

For a type to be used within the workflow, it must be registered as an Authorized Type in the web.config file. All of the Nintex workflow actions and custom types are registered as authorized types.
Some of the workflow actions have a property of a type that inherits from a generic list, that is List<T>. List<T> is a basic system type provided in .NET.
With SharePoint 2010, List<T> is no longer authorized. Workflow actions that use a type that inherits from List<T> no longer run or publish.
The SharePoint web service to validate workflows returns the following error when publishing:
<Error><CompilerError Line="0" Column="0" Text="Type System.Collections.Generic.List`1, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 is not marked as authorized in the application configuration file." /></Error>

Work around:Add the following to the web.config of the SharePoint web application on which you want to publish the workflow.

Save the web.config and return to SharePoint and now you will be able to successfully publish the same workflow (containing the Task Reminder):

Enjoy !

Also refer to: http://connect.nintex.com/forums/thread/239.aspx

SharePoint 2010 Incoming e-mail Settings on Windows 7

2011-02-03T16:51:00.004+02:00

Recently I needed to enable a SharePoint 2010 document library to accept incoming emails and then use the data from the body of the email to update list values.
It is really easy to configure SharePoint 2010 for incoming email and to enable a specific document library to receive emails.
You will find a few good tutorials on the web to help you achive this.
One of the very first things which you need to do is to install and configure a SMTP service on your SP2010 web front-end server. That is exactly where I ran into problems as my SP2010 web front end server is running on Windows 7.
Unfortunately Windows 7 does not ship with SMTP Service and almost all the documentation showing how to configure your SP2010 WFE for incoming mail focus on Windows 2008 server.
Many thanks to Wesley Bakker for the clear and helpful instructions which he posted at http://weblogs.asp.net/wesleybakker/archive/2010/08/09/configure-hmailserver-for-sharepoint.aspx
This short tutorial will illustrate how I managed to get my SharePoint 2010 incoming email configured on my Windows 7 web front-end server.
1. Download hMailServer from http://www.hmailserver.com/
2. Install hMailServer and create a new Administrator password when prompted.
3. Configure hMailServer in the following way:

(If I do not specify a setting to be changed then accept the default)
After the install completed, add a new domain. You can use anything.
In the new hMailServer domain create two new email accounts

Expand Settings and click on SMTP. Set the ‘Local host name’ to your local machine name.

Expand ‘Advanced’ and then expand ‘IP Ranges’ and click on ‘Localhost’. I changed the Name, Lower IP, Upper IP values and I removed the requirement for SMTP authentication.

Because hMailServer does not have an email drop folder by default, you have to create a folder structure to use as a drop folder. I created the following folder structure to use as my drop folder: C:\Program Files (x86)\hMailServer\Data\JohanSPSDev.local\Dropfolder\
Microsoft SMTP server adds header information to emails which hMailServer does not do, so if the information is missing SharePoint will not accept the emails into the library. So in order to prevent this you need to add a script to hMailServer to include the header information into the emails before there are dropped into the drop folder for SharePoint.
This process is very clearly explained by Wesley Bakker in his post: http://weblogs.asp.net/wesleybakker/archive/2010/08/09/configure-hmailserver-for-sharepoint.aspx

In hMailServer expand ‘Advanced’ and then click on ‘Scripts’.
Enable Scripts and click on Show Scripts. Open the existing script file in notepad and add the following text.
Ensure to change the drop folder path to your own configuration.
After you made the changes save the file and close it.
Back in hMailServer click on ‘Check syntax’ and then on ‘Reload scripts’.

4. Test your SMTP Service:

Now our hMailServer should be up and running and we are ready to test whether we can send and receive email… because I also have a corporate email account and I have Outlook installed the easiest for me was to create a POP account in Outlook and point it to my new domain.

The important thing here is to use an IP address of your local machine instead of using the word localhost or even your pc name. I tried my pc name as well as localhost but when I tested the account settings it kept failing… I only got it to work after I provided the IP address.
After I finished configuration of my POP3 account in Outlook I received the following test email in my inbox as confirmation that my SMTP service is working fine

So now that our SMTP Service is working the next step is to configure SharePoint.
Open Central Administration and go to System Settings.
Click on ‘Configure incoming e-mail settings

Set ‘Enable sites on this server to receive e-mail’ to ‘Yes’
Ensure that you change the e-mail server to match that of the new domain which you created in hMailServer and specify the drop folder which you manually created earlier.
Click on OK to save your settings.

To test that it is working create a new SP2010 document library and go to the library settings. Click on ‘Incoming e-mail settings’

5. Configure the Incoming e-mail settings for the library:

Configure the Incoming e-mail settings for the library as illustrated in the screenshot below and click on ‘OK’ to save the settings. Note that I specify an e-mail address which of an account which I created in hMailServer earlier.

6. Test Everything:

Go back to Outlook and select the new POP3 mailbox. Create a new email to be sent from this account and send a test email to the email address of the document library and send the email.

After outlook performed a send-receive and the email is in your ‘sent items’ go to SharePoint and refresh the document library.
If everything went well you should see the new email in you library.

Note that when a library is configured to accept incoming email SharePoint will automatically add new columns to the library, but the new columns is not automatically added to the default view..so you can modify the view to see the additional information from the email:

You will also notice that the body of the email is not available as a column.
It is very easy to extract the body information by using an eml reader class. I will how you how to do this in a separate post.
Keep in mind that your environment might be very different than mine and there can be a million things configured which might have an impact on getting this to work for you. My anti-virus was not a problem and my hMailServer service was automatically started.
I hope this post will help you to get incoming e-mail configured for SharePoint 2010 on a Windows 7 machine.
Have fun!!

SPFarm.Local is null (x86 vs. x64)

2011-01-28T11:14:00.002+02:00

This is one of those silly little mistakes which we very often overlook…and believe it or not, I have found many forums and blog posts where developers ask for help on this.
I wanted to work with the SPFarm.Local object earlier this week and forgot that SharePoint 2010 targets the 64bit platform …duh… so when I tried the following code:
private void cmdCreateWebApp_Click(object sender, EventArgs e)
{
int myPort = 999;

            SPFarm farm = SPFarm.Local;
            SPWebApplicationBuilder webAppBuilder = new SPWebApplicationBuilder
            (SPFarm.Local);

            webAppBuilder.Port = myPort;
            SPWebApplication newApplication = webAppBuilder.Create();
            newApplication.Provision();
            SPSite mySiteCollection = newApplication.Sites.Add("/",
           @"Mydomain\MyAdminUserName", "MyAdminUserEmail@CompanyName.co.za");
            mySiteCollection.Close();
        }
I kept getting an exception and found that SPFarm.Local remains null.

The problem was that my VS2010 project was set to target a x86 platform and not the x64!!
So, I opened my project properties and changed the platform target to x64.

Recompiled my code and ran it and it worked like a charm !

Always remember guys…. X64 !!!!!

WSPBuilder Error x86 vs. x64 (SP 2007)

2010-12-23T15:34:00.002+02:00

Today I came across 2 errors:

Feature 'featureid' is not installed in this farm, and can not be added to this scope.
Cannot add the specified assembly to the global assembly cache: cablib.dll.

I tried to deploy a WSP solution which we created a few weeks ago into a test SharePoint 2007 (MOSS) environment.
I am using the CodePlex.SharePointInstaller (Setup.exe) and my solution.wsp file.
This works well if I install it on my dev environment, but as soon as I try to install it on the test environment I get the following error at the very last step of the installation wizard.
Error: Cannot add the specified assembly to the global assembly cache: cablib.dll.

I checked the 12 hive and my feature files are all there, but as soon as I try to activate a feature which contains an event receiver (assembly should be in GAC) I get the following error:
Feature 'dc618366-db0a-4912-88d1-ad59e55bac90' is not installed in this farm, an
d can not be added to this scope.
After a bit of head-scratching I realized something. The solution was built on a 64bit dev environment and I am trying to install into a 32bit test environment.
So this is what I had to do to get it to work:
In Visual Studio, open you WSPBuilder project and go to project –> properties. Then change the Platform Target to x86.

Save your project and build it.
Reinstall the WSP (run the SharePoint Solution Installer for your WSP to remove the old version and then run it again to install the new version.)
This time the assemblies can be deployed to the GAC and you will now be able to activate your feature !!!
Enjoy !

SP2010 Basics: Client Object Model

2010-10-22T21:27:00.031+02:00

This post is part of the series which I will share in order to help you understand the new architecture of SharePoint 2010 and the impact thereof on you as developer.

This week I had the opportunity to be a speaker at the AvePoint Interactive Theater at Teched Africa 2010.

I decided to present an understanding of the SharePoint 2010 Managed Client Object Model. This is an introduction to how the Client Object model works, the benefits it brings and some very important considerations you have make.

So...lets get cracking...

The Standard SharePoint 2007 Implementation
This diagram shows the standard communication between a SharePoint client browser and the server in a non customized environment.
You can see that there is nothing special required on the client side. Simple comms to the server and then some execution there.

What do we want to achieve?
Sometimes we want to extend SharePoint by adding functionality which will execute on the client-side. This means we want some mechanism to execute code on the client-side but then still interact with SharePoint data and functionality which reside on the server.
Examples of this will be:
1-Building Silverlight components,
2-Build web parts which contains client side code like ajax or silverlight,
3-Extend an existing Windows forms application which contains client-side code.

The Challenges in SharePoint 2007
The first challenge we faced in SharePoint 2007 was that if we wanted to extend an existing application which runs on the client side. In order to utilize SharePoint you had to use the native SharePoint Web Services or build new custom web services which will be hosted on the SharePoint server. Remember that custom web services will use the server object model. Deploying custom web services onto the server creates an administrative overhead and introduces a risk.

The second challenge is in building silverlight applications which execute client-side.

So it is very obvious that we needed some mechanism to build client-side code which has an awareness and access to the SharePoint Server Object Model.

Microsoft helped solve this problem for us by introducing the SharePoint 2010 Client Side Object Model. Now we have a mechanism to extend SharePoint functionality through client-side code..without using SharePoint Web Services !!!

How does the Client-Side Object Model work?

From the diagram you will see that we have the client on the left and the server on the right. The server contains the SharePoint Databases and the Server-side Object model.
Between the server and client is a new WCF service called Client.svc
When you reference the client-side object model in your code (example later in this post) , the internal proxy class takes care of sending requests and review responses via the WCF Service.

The very important thing to notice here is that we dont want to send requests to the server and get a response for almost every line of code we execute. So how it is designed to work is that in your code you will construct the objects and execute standard SharePoint OM functions. The objects will be empty structures without properties and without data, and the functions will not execute right away.
Then at logical points you bundle everything together and send it to the server for processing. The server will then unpack your bundled code and execute it in the correct order and return JSON to your client-side. Your objects will then be populated with data and properties and you can carry on executing more code. The important concept to understand is that you bundle empty objects together and send to the server when ready for processing.

The SharePoint Foundation 2010 managed client model consist of Two Assemblies that contains five namespaces.

There are 3 types of client object models.
1-Managed Client Object model
2-Silverlight Client Object model
3-ECMAScript Client Object model

1-Managed Client Object model:
This is used to extend Windows Form applications, services, WPF applications, console applications etc.
It consist of Microsoft.SharePoint.Client.dll (282 kb) and
Microsoft.SharePoint.Client.Runtime.dll (146 kb)

2-Silverlight Client Object model:
This is used to Silverlight Applications.
It consist of Microsoft.SharePoint.Client.dll (282 kb) and
Microsoft.SharePoint.Client.Runtime.dll (146 kb)

3-ECMAScript Client Object model:
JavaScript in our SharePoint user interface.
It consist of:
CUI.js (344 kb)
SP.js (381 kb)
SP.Core.js (13 kb)
SP.Ribbon.js (208 kb)
etc...

You will notice that there are a few differences between the objects in the Client-Side Object model and the Server-side Object model:

Lets build some simple code:
Create a new Visual Studio 2010 Console application
Add a references to:
Microsoft.SharePoint.Client.dll and
Microsoft.SharePoint.Client.Runtime.dll
ensure your console app code look as follows:

using System;
using Microsoft.SharePoint.Client;
class DisplayWebTitle
{
static void Main()
{
ClientContext clientContext = new ClientContext("http://ltp-21:17819/");
Web site = clientContext.Web;
clientContext.Load(site);
clientContext.ExecuteQuery();
Console.WriteLine("Title: {0}", site.Title);
}
}

Press control+F5 and see your code execute.

Lets analyze the code:
You inform the managed client OM about the operations that you want to take.
This includes accessing the values of properties of objects (for example, objects of the List class, ListItem class, and Web class), CAML queries that you want to run, and objects such as ListItem objects that you want to insert, update or delete.
Then you call the ExecuteQuery method.
Only when you call the ExecuteQuery will the objects be bundled up and sent to the server for processing.
No network traffice occurs before then.

Another Example:
Create a new Visual Studio 2010 Console application
Add a references to:
Microsoft.SharePoint.Client.dll and
Microsoft.SharePoint.Client.Runtime.dll
ensure your console app code look as follows:

using System;
using Microsoft.SharePoint.Client;
class Program
{
static void Main()
{
ClientContext clientContext = new ClientContext("http://ltp-21:17819/");
List list = clientContext.Web.Lists.GetByTitle("Announcements");
CamlQuery camlQuery = new CamlQuery();
camlQuery.ViewXml = "<View/>";
ListItemCollection listItems = list.GetItems(camlQuery); clientContext.Load(list);
clientContext.Load(listItems);
clientContext.ExecuteQuery();
foreach (ListItem listItem in listItems)
Console.WriteLine("Id: {0} Title: {1}", listItem.Id, listItem["Title"]);
}
}

Press control+F5 and see your code execute.

Again, the code will be bundled up and only be sent to the server for processing when the .ExecuteQuery() run.
This means that although you called the list.GetItems the CAML did not execute at that time.
When you call the .ExecuteQuery(), the server will receive your code, unpack it and execute it in the correct sequence and return the objects populated with data and properties.... all processed on the server side... and ready to be further used on the client-side !!!!

Amazing, isnt it ! Well I hope this gives you a nice overview of the Client Side Object model in SharePoint 2010.

Have Fun !

SharePoint 2007 Site Templates vs. Site Definitions

2010-08-23T21:30:00.003+02:00

There is an ongoing debate between SharePoint developers regarding the best approach for packaging and deploying customized SharePoint solutions.
One easy approach is to use site templates, but my opinion is that for a developer who are concerned about system performance and who needs finer control over cusomization, a site definition is the better option.

I found that building some sort of custom site provisioning provider works the best.

Below is my analysis of the differences between site definitions vs. site templates and at the bottom is a summary of the approach I prefer for deploying custom SharePoint solutions.

What is a Site Definition?
A Site definition is the core definition of what a site is in SharePoint.
User content on a SharePoint site is located in a SQL Server database.
All the code and the pages that are used to administer and render the SharePoint site are stored as physical files on the web server.
A site definition exists as physical files on the web server and defines, through the use of SharePoint’s XML schema (known as CAML), the lists, columns, features etc. that should be created / activated when a site is created. (The files includes .aspx pages and .xml files)
A site definition is installed on file system of web front ends, located at ..\12\Template\SiteTemplates. This directory is language-neutral.
Site definition files are cached in memory on the server at process start-up of Microsoft Internet Information Services (IIS), which improves scalability and performance by reducing unnecessary data storage or retrieval, and by allowing uncustomized pages to be reused across sites. The information contained in these files is pulled from the cache at run time. Pages and list schemas are read from the site definition files but appear to be actual files within a site.

What is a Site Template?
A site template (*.stp file) is created through the user interface or through implementation of the object model. It is a package containing a set of differences and changes from a base site definition.
The site template package is stored as a CAB-based file that can be downloaded or uploaded to site collections by users with the appropriate rights.
It is not as performant as a pure site definition as site definitions are cached on start of IIS on the web front ends while site templates are stored and hence need to be fetched from the content database and merged with the site definition code at runtime to render the site.

Deciding Between Site Definitions and Custom Site Templates

Site Templates

Easy to create.
You do not need to be a server administrator on the Web server to create and deploy site templates.
Easiest way for system administrators to extend SharePoint without requirement for development skills.
Deployment is simple because template data is stored centrally in the configuration database.
Because it is slow to store templates in and retrieve them from the database, site templates can result in slower performance.
The contents of unghosted pages are routed through the Safe Mode parser, which prevents server-side code from executing, and which depends entirely on the Safe Controls list specified in the web.config file of the wwwroot directory to determine which controls can be rendered at run time.
You can modify a site template without affecting existing sites created by the template.
Custom templates can be modified without affecting existing sites that have been created from the templates.
Custom templates are not created in a development environment.
If the site definition on which the custom template is based does not exist on the front-end server or servers, the custom template will not work.
If you plan to transfer a site template to separate farm, that the farms have the same versions installed of SharePoint installed. (hotfixes,etc.) This is due to the dependence site templates have on the original base site definition they were created from.

Site Definitions:

Complex and laborious to create.
Administrators must always be involved in the deployment of site definitions.
Most appropriate for third-party developers.
Deploying a site definition requires more work.
Site definition files are cached in memory on the server at process start-up of Microsoft Internet Information Services (IIS), which improves scalability and performance by reducing unnecessary data storage or retrieval.
Uncustomized pages to be reused across sites.
You can achieve a finer level of customization by directly editing all the schema files.
Custom site definitions are version and upgrade independent.
Subsequent upgrades to SharePoint Products and Technologies may overwrite existing default site definitions. Using custom site definitions excludes your sites from potential upgrade issues.
There is no easy way to modify site definitions once they are deployed
Doing anything other than adding code can break existing sites
Users cannot apply a SharePoint theme through a site definition.
Customizing site definitions requires access to the file system of the front-end Web server.
Multiple root-level pages -- In a site definition, you can define several root-level pages. Instead of your sites having one page, they can have many.
Template picker pages -- You have the ability to change the icon that displays in conjunction with the template so it stands out as you create the templates.
Microsoft doesn't support changes made to a site definition after you've created the sites.
Multiple lists of the same type -- Because of the structure of CAML and the ONET.XML file, you can't create multiple lists from the same list definition and put them on the same page.

Summary of my preferred approach:
I found that building a custom site provisioning provider works the best.
This means that I build my SharePoint artefacts - lists, libraries, web parts, custom forms, etc. using SharePoint, SharePoint Designer and Visual Studio. When I am then ready to package and deploy my custom SharePoint solution I use the SharePoint Solutions Generator - part of Microsoft SharePoint Developer Tools 9.0 to create list and library definition features.
Once I have my list and library definitions in place I create a Visual Studio WSP Builder project with an Feature Event Receiver.
In the "activate" event I add logic to activate the definition features and in the "deactivating" event I do a cleanup (deactivate definition features and remove web parts)

This means the following will happen when one of my solutions are deployed / retracted:
1. The user creates a blank SharePoint site. (previously team site)
2. The user runs a Setup.exe file.
3. This file is the un-customized Codeplex Solutions Installer and will read configuration data from Setup.exe.config
4. The file will open a deployment wizard which guides the user through a series of screens to ensure successful solution deployment.
5. After successful deployment the user follow instructions from the deployment guide to execute a single stsadm.exe command.
6. This command will activate a single hidden feature.
7. The single feature which gets activated will do the following on the site:

Set the new site title.
Check environment for previously installed features which are still active
Activate Web Features in the correct order
Activate Site Collection Features
Allows activation of generic site collection features – shared among more than 1 solution.
Clear Site Structure – remove unwanted artefacts
Set Site Structure – build Quick Launch Items, Set Web Parts on Default.aspx page etc.

8. During deactivation of the single “configuration” feature the following will happen:

Set the new site title back to default.
Deactivate Web Features in the correct order
Deactivate Site Collection Features
Clear Site Structure – remove unwanted artefacts
I do not delete lists or libraries which contain data – do not want to delete data.

Benefits of this approach:

Allows dependencies between hidden features - lookup lists
Allows list to be automatically instantiated with default data
Allows library content – like UDCX files to be configured with new environmental values (link InfoPath Form to dynamic data connections)
Allows activation of web part features to site collection scope
Allows validation and upload of InfoPath Forms (using site collection feature)
Allows publishing of InfoPath Form to site collection forms library
Leverage off the benefits of using definitions.

I hope this will help you to choose the best approach for the kind of SharePoint solutions which you need to deploy... good luck !!

Further reading and references:
http://itfootprint.wordpress.com/2007/04/18/sharepoint-site-template-vs-site-definition/
http://msdn.microsoft.com/en-us/library/ms980852.aspx
http://mymemorysucks.wordpress.com/2009/02/25/site-definitions-vs-site-templates-and-site-provisioning-providers/
http://my.advisor.com/doc/17614
http://blogs.msdn.com/b/brianwilson/archive/2008/07/13/site-definitions-versus-site-templates-and-deciding-on-the-correct-customization-approach.aspx

SharePoint 2010 Provider Consumer Web Parts

2010-08-16T22:17:00.018+02:00

In this tutorial I will show how to develop Provider and Consumer web parts and connect them through an Interface.
The result will be the ability to have two web parts on a SharePoint 2010 page and filter the contents of the consumer web part on the data from the provider web part. This is almost like a master - detail view.
You can view the same functionality by looking at the standard SharePoint web parts. Modify a web part --> select Connections and the "Provide data to..." or "Receive data from..."

and then...

Lets Get Started:
I will show the detailed steps to:
1 - Develop a Connection Interface
2 - Develop a simple provider web part.
3 - Develop a simple consumer web part.

1 - Develop a Connection Interface.

Open Visual Studio 2010 and create a new project. In the New Project dialog window, select Visual C# --> SharePoint 2010 --> Empty SharePoint Project.
Provide a descriptive name and click on OK.
Select to deploy the solution as a "Deploy as Farm Solution" and click on Finish.
Wait for the solution to be created in Visual Studio.

Now we will create the web part connection interface which is responsible for exchanging connection information between a provider and consumer web part.
In the Solution Explorer, right-click on your project and select "Add --> New item".
In the Add New Item dialog window, select Visual C# --> Code --> Interface.
Enter ITask in the Name textbox and click the Add button.
Open ITask.cs in code view and change the visibility of the interface to Public and add the following code inside the interface:
namespace WebPartConnectors
{
   public interface ITask
   {
      int Id { get; }
      string Name { get; }
   }
}

2 - Develop a simple provider web part:
In the Solution Explorer, right click on your project and select Add --> New Item…
Select Visual C# --> SharePoint 2010 Web Part.
Enter ProviderWebPart in the Name textbox and click Add.
Open ProviderWebPart.cs in code view and in the ProviderWebPart class declaration, implement ITask.
public class ProviderWebPart : Microsoft.SharePoint.WebPartPages.WebPart, ITask

Insert the following code after the ProviderWebPart class declaration.
This code block implements the ITask web part connection interface and adds a local variable to the web part.
DropDownList _objPicker = null;
int ITask.Id
{
    get
   {
   return int.Parse(_objPicker.SelectedValue);
   }
}
string ITask.Name
{
   get
   {
     return _objPicker .SelectedItem.ToString();
   }
}

Update the CreateChildControls method to contain the following code:

protected override void CreateChildControls()
{
try
{
    _objPicker= new DropDownList();
    using (SPSite spSite = new SPSite(SPContext.Current.Web.Url))
    using (SPWeb spWeb = spSite.OpenWeb())
    {
     SPList objList = spWeb.Lists["Tasks"];

      foreach (SPListItem objListItem in objList.Items)
      {
        _objPicker.Items.Add(new ListItem(objListItem.Title, objListItem.ID.ToString()));
      }
     }
     _objPicker.AutoPostBack = true;
     this.Controls.Add(_objPicker);
}
catch (Exception ex)
{
    this.Controls.Clear();
    this.Controls.Add(new LiteralControl(ex.Message));
}
}

Insert the following ConnectionProvider property below the CreateChildControls method. This provides the Connection Provider interface point for the ProviderWebPart: [ConnectionProvider("Task Name and ID")]
public ITask NameDoesNotMatter()
{
return this;
}

Save your solution and build. Ensure that there are no build errors before you proceed.

3 - Develop a simple consumer web part.
In the Solution Explorer, right click on your project and select Add --> New Item…

Select Visual C# --> SharePoint 2010 Web Part.
Enter ConsumerWebPart in the Name textbox and click Add.

Insert the following code inside the ConsumerWebPart class declaration:
ITask _provider = null;
Label _lbl = null;

Update the CreateChildControls method to contain the following code:
protected override void CreateChildControls()
{
try
{
_lbl = new Label();
if (_provider != null)
{
if (_provider.Id > 0)
{
_lbl.Text = _provider.Name + " was selected.";
}
else
{
_lbl.Text = "Nothing was selected.";
}
}
else
{
_lbl.Text = "No Provider Web Part Connected.";
}
this.Controls.Add(_lbl);
}
catch (Exception ex)
{
this.Controls.Clear();
this.Controls.Add(new LiteralControl(ex.Message));
}
}

Insert the following ConnectionConsumer property below the CreateChildControls method. This provides the Connection Consumer interface point for the ConsumerWebPart:[ConnectionConsumer("Name and ID")]
public void ThisNameDoesNotMatter(ITask providerInterface)
{
_provider = providerInterface;
}

Save the solution, Build the solution and Deploy the solution.
Go to your target SharePoint 2010 site and refresh the site.
Edit a page and add the two new web parts.(ensure that you have some data in the SharePoint Tasks list)

View your two new web parts on the page:

Edit the page again and select the ProviderWebPart and click on Edit Web Part.

Select the ProviderWebPart again, but this time select "Connections" --> "Send Task Name and ID To" --> ConsumerWebPart.

Now, if you select an item from the dropdown list control in the providerwebpart you will see the corresponding data change in the consumerwebpart.

This way you will be able to build master-detail views or web part filters based on selections of other web parts.

Enjoy !!

Basic SharePoint 2010 LINQ Web Part

2010-08-16T13:03:00.000+02:00

In this tutorial I will show how to develop a very basic visual web part which uses LINQ (LINQ to SharePoint) to populate data from a SharePoint 2010 list into a SPDataGrid control.

The web part will look like this:

Overview:
The following steps will be taken to develop the web part which contains LINQ.
1- Create a Visual Web Part.
2- Create a LINQ proxy class.
3- Use a LINQ provider to read data from a SharePoint list.
4- Show the data in a SPDataGrid control.

Lets get started
1- Create a Visual Web Part:

Create a new Visual Studio 2010 project. From the installed templates select Visual C# --> SharePoint --> 2010 --> Visual Web Part.
Provide a suitable name and click on OK.

Select to deploy the solution as a Farm Solution and click on "Finish"

Once the project is created, open the VisualWebPart1.webpart (from the solution explorer)
Change the Title and Description values and save the file.
<properties>

<property name="Title" type="string">MyFirstSPLinqWebPart</property>
<property name="Description" type="string">My First SQL LINQ Web Part</property>
</properties>

2- Create a LINQ proxy class.
In the Solution Explorer, right-click on your project and select Open Folder in Windows Explorer.

Hold Shift key and right click anywhere in the Explorer Window and select Open Command Window Here to open the command prompt window in the current project directory.

Type the following command in the command prompt and press Enter to set the path to the SharePoint 2010 folder:

set path=%path%;c:\program files\common files\microsoft shared\web server extensions\14\bin

Type the following command in the command prompt and press Enter to generate the Linq-to-SharePoint proxy code.
the yoursharepointsiteaddress value should reflect the URL of your SharePoint 2010 site.
(mine was http://svr-x:12345/)
For yourwebpartnamespace value I used MyFirstSPLinqWebPart.VisualWebPart1.
spmetal.exe /web:http://yoursharepointsiteaddress /namespace:yourwebpartnamespace /code:SPLinq.cs
so my command looked like:
spmetal.exe /web:http://svr-x:1234 /namespace:MyFirstSPLinqWebPart.VisualWebPart1 /code:SPLinq.cs

Note – you may get warnings about content types for list Form Templates. You can safely ignore this warning and continue.
Close the command window and switch back to Visual Studio.
In Visual Studio, in the solutions explorer, right click on your project and select Add Existing Item --> Navigate to the SPLinq.cs file (should be in your project folder)..select the file from the Add Existing Item dialog window and click Add.

Next we will add a reference to Linq to our project.
In the Solution Explorer right click on References and click on "Add Reference".
Select Microsoft.SharePoint.Linq from the list of .net references and click on OK.
(the file is available on the server as C:\Program Files\Common Files\Microsoft Shared\Web Server Extensions\14\ISAPI\Microsoft.SharePoint.Linq.dll)

3- Use a LINQ provider to read data from a SharePoint list & populate the GridView:

In Solution Explorer, expand VisualWebPart1 and double-click on VisualWebPart1UserControl.ascx.

Add the following code to the bottom of the file below the code which already exists in the file..
This is to generate the user control to construct the grid view.
<%@ Import Namespace="Microsoft.SharePoint.WebControls" %>
<SharePoint:SPGridView id="spGridView" runat="server" AutoGenerateColumns="false">
     <HeaderStyle HorizontalAlign="Left" ForeColor="Navy" Font-Bold="true" />
         <Columns>
             <SharePoint:SPBoundField DataField="Title" HeaderText="Title"></SharePoint:SPBoundField>
             <SharePoint:SPBoundField DataField="Body" HeaderText="Body"></SharePoint:SPBoundField>
             <SharePoint:SPBoundField DataField="AssignedTo"
                                 HeaderText="AssignedTo"></SharePoint:SPBoundField>
         </Columns>
</SharePoint:SPGridView>

In the Solution Explorer, right click on VisualWebPart1UserControl.ascx and select View Code. Add the following using statements to the code behind:
using Microsoft.SharePoint.Linq;

using Microsoft.SharePoint;
using System.Linq;
Insert the following code inside the Page_Load method:
SPLinqDataContext dc = new SPLinqDataContext(SPContext.Current.Web.Url);

EntityList<Task> Tasks = dc.GetList<Task>("Tasks");
var empQuery = from taskitem in Tasks
      select new
      {
          taskitem.Title,
          Body = taskitem.Body,
          taskitem.AssignedTo,
      };
spGridView.DataSource = empQuery;
spGridView.DataBind();

Build the project and deploy.
Refresh your SharePoint site.
Edit an existing page and add your new web part to the page (select your new web part)

You will now see the data which is loaded from a SharePoint list using LINQ and represented in a SPDataGrid.

Enjoy !!

SharePoint 2010 Ribbon Custom Command

2010-08-15T19:41:00.008+02:00

In this last tutorial I show how to create a Web Part which adds a command to the Ribbon. This is an introduction to customizing the SharePoint 2010 Ribbon using custom actions.

Lets get started:
Create a new Visual Studio 2010 Project.
Select SharePoint and then Empty SharePoint Project.
Name the project and click on OK

Specify the site to use for debugging, select "Deploy as farm solution" and click on Finish.

Using the Solution Explorer, add a new item to the project.
Select Visual C# --> SharePoint 2010 --> Empty Element.
Name the element RibbonActions and click on "add"

In the editor for the Elements.xml file that has opened automatically add a new <CustomAction> element right inside the <Elements> node and add the following markup. (your project will contain two Elements.xml files. One under MyRibbonWebPart and another under RibbonActions. The changes required here is for the Elements.xml file under RibbonActions)

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

<Elements xmlns="http://schemas.microsoft.com/sharepoint/">
<CustomAction
    Id="Hello_world"
    RegistrationType="List"
    RegistrationId="101"
    Location="CommandUI.Ribbon"
    Sequence="5">
    <CommandUIExtension>
       <CommandUIDefinitions>
         <CommandUIDefinition Location="Ribbon.Documents.Manage.Controls._children">
            <Button
               Id="Ribbon.Documents.HelloWorldButton"
               Alt="Hello World"
               Sequence="5"
               Command="Show_HelloWorld"
               Image32by32="/_layouts/images/placeholder32x32.png"
               LabelText="Hello World Command"
               TemplateAlias="o1"/>
          </CommandUIDefinition>
      </CommandUIDefinitions>

    <CommandUIHandlers>
      <CommandUIHandler
        Command="Show_HelloWorld"
        CommandAction="javascript:alert('Hello World!');" />
      </CommandUIHandlers>
    </CommandUIExtension>

</CustomAction>
</Elements>

Save the project and build the project.
In the Solution Explorer, right-click on the project and choose Deploy.

Open the web.config file of the web application which hosts the SharePoint site which you deployed to.
Add a SafeControls entry for the new assembly.(remember that your PublicKeyToken value will be different)
<SafeControl Assembly="MyRibbonWebPart, Version=1.0.0.0, Culture=neutral, PublicKeyToken=3d7d18f076284cdb" Namespace="MyRibbonWebPart.MyRibbonWebPart" TypeName="*" Safe="True" AllowRemoteDesigner="True" />

Save and close the web.config file.
Navigate to the target SharePoint Site, go to Site Actions -->Site Settings --> Manage Site Features and activate the new feature.

Navigate to a document libary and click on "Documents" group in the Ribbon. Notice the new action item.

Click on the new custom action to view execution of the javascript.

Enjoy !!

Nintex Workflow 2010 Installation

2010-08-04T17:38:00.002+02:00

Today I installed and configured Nintex Workflow 2010 for SharePoint 2010.

I must say, the guys at Nintex are doing a brilliant job and their product documentation is clear and easy to follow.
I had absolutely no problems installing Nintex Workflow 2010 on my SharePoint 2010 sandbox and this tutorial will show how easy it is to prepare a Nintex Workflow 2010 environment.

The reasons for choosing Nintex Workflow 2010 as a workflow designer tool deserve a separate post, but for a quick overview please have a look at this site.

Prerequisites:
In my environment I had the following in place before installing Nintex Workflow 2010:
* Windows 2008 Server
* Microsoft Office SharePoint Server 2010
* SQL Server 2008 (and other prerequisites to run SharePoint 2010)
* SMTP Server (outside of the SharePoint Farm)
* SMTP Service configured on Windows 2008 server (see instructions)
* Outgoing email settings configured for SharePoint Farm (see instructions)
* Outgoing email settings configured for SharePoint Web App (see instructions)

Installation & Configuration:
The install is very simple.
I followed the installation guide which is available on this site under technical information.

The following steps need to be followed:
1 Install the Nintex Workflow 2010 solution package
2 Perform Database Configuration
3 Configure Workflow Server Settings
4 Activate Features

1 Install the Nintex Workflow 2010 (NW2010) solution package:
To install the NW2010 solution package is really very easy.
Ensure that you are logged in to the server as local admin.

1.1 Run the NintexWorkflow2010.msi from the local machine.
        Follow the steps through the wizard until finished.

I got a error during installation complaining that the assembly failed in the zone "My Computer"
To solve this make sure that User Account Control is turned off or set it to the very minimum.
Follow these steps:
1.Click on Start, and then Control Panel
2.In Control Panel, click User Accounts
3.In the User Accounts window, click User Accounts
4.In the User Accounts tasks window, turn the User Account Control to the very minimum
5.Restart to apply the changes

1.2 Deploy the solution to web applications.
       Open the SharePoint 2010 Central Administration
       go to 'System Settings' and then to 'Manage Farm Solutions'
       You will see 2 new solutions in the list of solutions in the farm.
       They are:
         nintexworkflow2010.wsp and
         nintexworkflow2010enterprisefeatures.wsp
       Deploy both solutions to all content web applications.
       After both solutions have been deployed successfully you should see the following
       status:

       In order to activate the NW2010 configuration functionality in Central Admin, you
       have to deploy the nintexworkflow2010enterprisefeatures.wsp solution again, but
       this time select only the Central Admin web application as the "Deploy To" location.
       It is not necessary to retract the solution first, just deploy it again.
   1.3 The next step is to import the Nintex License.
       If you return to the Home page of Central Admin you will notice a new configuration
       section called "Nintex Workflow Management".

Click on 'Nintex Workflow Management' and select 'Licensing'

From here you can click on the 'Import' button... to import your license file.

Ok, once this is all done we are ready to:

2- Configure the Nintex database.

In Central Admin go to the Nintex Workflow Management section.

Click on the "Database Setup" link and then click on the "Create" button.

Provide details of your database server and click on the "OK" button to allow the database to be generated.

The cool thing here is that in previous versions of Nintex Workflow (for SharePoint 2007) it was really tricky to get the database connection details working in a single server installation. It seems like it has all been taken care of since I am able to use my Windows Authentication to access the database without any problems.

Great, we are moving ahead... the next step is to:

3 - Configure the Nintex Workflow 2010 Server Settings

This will require that we:

3.1 Perform Web Application Activation

3.2 Enable Workflow Actions

3.3 Configure Email Settings

3.4 Enable and Configure Lazy Approval

3.1 Perform Web Application Activation:

In Central Admin go to the 'Nintex Workflow Management' section and click on

"web application activation"

Activate the feature to the applicable web application.

    3.2 Enable Workflow Actions
          In Central Admin go to the 'Nintex Workflow Management' section and click on

          "manage allowed actions"
          Select the workflow actions which you want to allow in your farm and click on OK.

    3.3 Configure Email Settings
          In Central Admin go to the 'Nintex Workflow Management' section and click on

          "Global settings"
          Provide the appropriate smtp server settings and click on "OK"

3.4 Enable and Configure Lazy Approval
         In Central Admin go to the 'Nintex Workflow Management' section and click on

         "LazyApproval Settings"
         Click on the "Enable / Disable LazyApproval" shortcut to enable LazyApproval.

The last step is to:

4 - Activate Features

Go to the Site Collection Features of your site on which you want to use Nintex Workflow 2010. (In SP2010 it is located under "Site Settings" --> Site Collection Features under Site Collection Administration)

You will see the following new site collection features.

Enable all of them:

Go to the Site Features of your site on which you want to use Nintex Workflow 2010. (In SP2010 it is located under "Site Settings" --> Manage site features under Site Actions)

Congratulations, Nintex Workflow 2010 have now been installed and configured and you can begin building workflow solutions !!!

In my next post I will show how to build a simple workflow to test whether the installation was successful.

Enjoy !!

You will see the following new site features.
Enable all of them:

Add code to an InfoPath 2010 Form

2010-08-03T16:40:00.001+02:00

Today I started an investigation on the changes between InfoPath 2007 development and InfoPath 2010 development.

I really hope that InfoPath 2010 will bring more functionality and development flexibility as it really is a great "quick-win" tool for business which is sometimes crippled by a lack of development richness.

So.. one of my first questions was.. how easy is it to develop code behind (create custom code) for an InfoPath 2010 Form.

This tutorial will show you that it is still extremely easy to accomplish adding custom code, and my initial impression is that for a developer things will only become easier when moving to InfoPath 2010.

Prerequisites:

1. Make sure you meet the minimum system requirements (available here).
2. Install Visual Studio Tools for Applications (VSTA).
3. Choose a programming language (inside the InfoPath Forms Designer).
4. Add event handlers and code.

Let's get Started:
Open Microsoft InfoPath Designer 2010.
From the Form Templates Dialog, select "Blank Form".

Change the default Label on the form to something appropriate.
Since this is a first InfoPath 2010 tutorial, we cannot use anything else than "Hello World"
Click on the form and select the "Home" tab from the ribbon. Expand the controls pane to view the available controls.
Add a Button and a Text Box to your form under the "This is a 'Hellow World' label.

Your form will now look like this:

If you click on the 'Developer' tab in the ribbon, you will see you can se the programming language of the form.

When you click on the Language command you will see the 'Form Options' dialog with the 'Programming' section selected. In here click on 'Change Language' and specify the language of choice.

Once your development language has been specified you can go ahead to add custom code to your form.
In design mode, select the custom button on your form and you will notice the ribbon automatically changes to show 'Control Tools' pane.
Click on the Properties item and click on the 'Custom Code' command.

If your prerequisites were installed correctly, InfoPath forms designer will now open Visual Studio Tools for Applications and create a event handler for the button click event.
Inside the FormCode.cs you will see the following code:

public void CTRL1_5_Clicked(object sender, ClickedEventArgs e)

{
}

Add your custom code inside this event. I added some code to set the field value of the textbox (custom field) which I added earlier in this tutorial:

public void CTRL1_5_Clicked(object sender, ClickedEventArgs e)

{
    XPathNavigator domNav = MainDataSource.CreateNavigator();
    XPathNavigator field = domNav.SelectSingleNode("/my:myFields/my:field1", NamespaceManager);
    field.SetValue("Hello World");
}

Build your code and save the project.
Return to the InfoPath Forms Designer.
On the Home pane in the ribbon you will see on the far right the form preview command.
Click on this command to preview your form.

If you preview the form and click on the button you will see the custom code execute and add a value to the custom field which is then displayed in the textbox.
You can add breakpoints to your code to step through it if you want.

In the next post will I show how easy it is to publish the InfpPath form.

Enjoy !!

My Favourite SharePoint 2010 Enhancements (for developer) part 1

2010-07-26T15:32:00.004+02:00

There are a number of platform and tool enhancements for SharePoint 2010.

I picked out a few favourites which I briefly explain below:

LINQ to SharePoint (Language Integrated Query)
Data Platform Improvements
List Enhancements
Business Connectivity Services
Silverlight Integration
Managed Client Object Model
Sandbox Solutions
Visual Studio 2010 for SharePoint
WSP Changes
Developer Dashboard
Dialog Framework
SharePoint Designer 2010
Visio Services
InfoPath (changes)
Windows PowerShell

LINQ to SharePoint (Language Integrated Query)
LINQ is a feature of the programming languages C# and Microsoft Visual Basic .NET. Compilers are included with Visual Studio.
LINQ adds a SQL-like syntax and vocabulary to each of the languages, which can be used to query data sources. But unlike other languages and query syntaxes which vary from one type of data source to another, LINQ can be used to query, in principle, any data source whatsoever. For this reason, developers may find that it is the only query syntax that they ever need to know.
The LINQ to SharePoint Provider is defined in the Microsoft.SharePoint.Linq namespace. It translates LINQ queries into Collaborative Application Markup Language (CAML) queries. more details here...

Data Platform Improvements
The data platform improvements include: List Relationships, Unique Column Constraints, Data Validation, Column Formula Validation, etc
more details here...

List Enhancements
The list enhancements in SP2010 include: Bulk Operations, New capacity limits(more details here..), XSLT Views (more details here..)

Business Connectivity Services (BCS)
BCS is a set of services and features that provide a way to connect SharePoint solutions to sources of external data and to define external content types that are based on the external data. External content types resemble content types and allow the presentation of and interaction with external data in SharePoint lists (known as external lists), Web Parts, Microsoft Outlook 2010, Microsoft SharePoint Workspace 2010, and Microsoft Word 2010 clients. External systems that Microsoft Business Connectivity Services can connect to include SQL Server databases, SAP applications, Web services (including Windows Communication Foundation Web services), custom applications, and Web sites based on SharePoint. more details here...

Silverlight Integration
In Windows SharePoint Services 3.0, you could host a Microsoft Silverlight application in a Web Part. Microsoft SharePoint Foundation 2010 goes beyond by providing a built-in, extensible, Silverlight Web Part specifically designed to host Silverlight applications. Closely related to the new Web Part is Silverlight Cross-Domain Data Access (Silverlight CDA) that enables secure, cross-domain, integration between Silverlight applications and SharePoint Foundation deployments, and Silverlight CDA can be used by non-Silverlight external applications as well. more details here...

Managed Client Object Model

The SharePoint Foundation 2010 managed client object model lets you write client-side code to work with all the common objects in SharePoint sites. Through the object model, you can add and remove lists, add, update, and delete list items, change documents in document libraries, create sites, manage permissions of items, and add and remove Web Parts from a page.
With the SharePoint Foundation 2010 managed client object model, you can design client applications that access SharePoint content without installing code on the server that runs Microsoft SharePoint Foundation 2010. For example, you can build new categories of applications that include writing applications that are based on the Microsoft .NET Framework, rich interactive Web Parts, Microsoft Silverlight applications, and ECMAScript (JavaScript, JScript) applications that run client-side in a SharePoint Web Part.
more details here...

Sandbox Solutions
You can deploy a Microsoft SharePoint Foundation 2010 solution directly onto your SharePoint Foundation farm, or you can deploy the solution into a sandbox. A sandbox is a restricted execution environment that enables programs to access only certain resources, and that keeps problems that occur in the sandbox from affecting the rest of the server environment.

Solutions that you deploy into a sandbox, cannot use certain computer and network resources, and cannot access content outside the site collection they are deployed in.
more details here... and here.

Visual Studio 2010 for SharePoint
A number of areas for SharePoint developers in Visual Studio 2010 are worth mentioning. First, you get SharePoint project templates in the box, so you can start right away on solution development. Second, tooling has standardized on the Windows SharePoint Package (WSP) packaging standard, so when you import or deploy a solution to SharePoint, Visual Studio treats it as a solution package. Third, some great deployment and packaging features, such as solution retraction and custom deployment configurations, ship with the SharePoint tools in Visual Studio 2010. And last, the new SharePoint Explorer provides a view into native and custom artifacts (for example, lists and workflows) that exist on your SharePoint server.

WSP Changes
SharePoint 2010 improves the WSP format so that it is supported across all tools, allowing you to export your site through the browser, SharePoint Designer, and Visual Studio. This means that you can quickly upgrade or downgrade your solutions between the tools.

SharePoint Online, the Microsoft - hosted version of SharePoint, supports this format so that you can move solutions to the cloud without having to rework the package.

Developer Dashboard
The developer dashboard is a new feature in SharePoint 2010 that is design to provide additional performance and tracing information that can be used to debug and troubleshoot issues with page rendering time. The dashboard is turned off by default, but can be enabled via the object model or stsadm (and PowerShell too, I just haven’t put together the script for it yet). When the dashboard is turned on you will find information about the controls, queries and execution time that occur as part of the page rendering process; this information appears at the bottom of the page.

more details here...

Dialog Framework
SharePoint 2010 has a new framework for showing dialogs to the end-user. The dialogs allow people to work with some data without losing focus on the page they were working on to get things done. Closing the dialog will often cause AJAX based refreshes to give a sense of stateful-ness.

The dialog is of course extensible through JavaScript code. You can either show a separate page, or use a DOM element on the source page and show that. You can then determine when the dialog closes and what happens when it has closed.

more details here...

SharePoint Designer 2010
There have been a large number of changes to SharePoint Designer.

For a nice overview go to this post

Visio Services
Visio Services in Microsoft SharePoint Server 2010 is a service application that lets users share and view Microsoft Visio Web drawings. The service also enables data-connected Microsoft Visio 2010 Web drawings to be refreshed and updated from various data sources.

Visio Web drawings (*.vdw files) can be rendered by Visio Services and viewed in a Web browser. This lets users view Visio documents without having Visio or the Visio Viewer installed on their local computer. Basic exploration and navigation of these rendered Web drawings are supported within the Visio Web Access Web Part. Page designers can configure the user interface and functionality of the Web Part.
Visio Services can also refresh the data and recalculate the visuals of a Visio Web drawing hosted on a Microsoft SharePoint Server 2010 site. This enables published Web drawings to refresh connections to various data sources and to update affected data graphics and text fields. more details here...

InfoPath 2010 (changes)
InfoPath 2010 comes with a large number of enhancements which includes:
Easy customization of list forms with InfoPath, an InfoPath Form Web Part, Forms with code-behind can be deployed using sandbox solutions, creating a site template will produce a WSP package which includes the InfoPath forms, Forms Services forms now support WCAG 2.0 standard, InfoPath forms can be made available offline using SharePoint Workspace 2010, Forms Services also support FireFox and Safari.
more details here... and here.

PowerShell for SharePoint 2010
Windows PowerShell is a command-line scripting tool that provides an administrator full access to applicable application programming interfaces (APIs), along with the ability to unlock the capability to interact directly with SharePoint 2010 Products to manipulate Web applications, site collections, sites, lists and much more. In addition, the administrator has the ability to script cmdlets (pronounced "command-lets"), which makes for an improved experience from past product versions. more details here... and here

Other enhancements (not covered in this post):
Access Services
Central Administration (Redesigned)
Digital Asset Management
Enterprise Search
Excel Services
Health Monitoring
Managed Metadata
PerformancePoint Services
Enhanced Records Management
Changes to Social Computing (previous called Collaboration)
Upgrade

Enjoy !!

Custom settings for a SharePoint list or library

2010-07-25T18:23:00.007+02:00

Someone asked me this week if it is possible to store custom settings (configuration) on a SharePoint (WSS 3.0 and MOSS 2007) list or library.
Example: You have a list or library and you want to create a custom property (metadata)field and provide the user with an GUI to manage a setting value.

I looked into the various options and found it is indeed very simple to accomplish.
Many thanks to Margriet Bruggeman and Nikander Bruggeman for their contributions.
You can use the Rootfolder object which contains a System.Collections.Hashtable for storing and accessing properties.It is very simple.

To store the value you use:
SPContext.Current.List.RootFolder.Properties[strPropertyKey] = strValue;

SPContext.Current.List.RootFolder.Update ();

To retrieve the value you use:
strValue = SPContext.Current.List.RootFolder.Properties[strPropertyKey].ToString();

In order to make it easy for the user to manage such settings, one would add a custom action with Location="Microsoft.SharePoint.ListEdit".
This means that when the user go to a list or library and then select "Settings" a new hyperlink (shortcut) will exist on the settings page from where the custom settings can be managed. (this is not overriding the settings page but rather just adding a shortcut on it)

This tutorial will show how easy it is to develop the described functionality.

Overview:
We will develop the following 2 components:
1-Feature with Custom Action.
2-Custom aspx page with code behind to view,insert,edit & delete settings.

Lets get started:

Create a new VS2008 WSPBuilder Project.

Add a new item to the project. Select WSPBuilder and then 'Blank Feature'

Set the scope of the feature to web.

The Feature.xml file will look like:
<?xml version="1.0" encoding="utf-8"?>

<Feature Id="65a738a0-a095-489e-be19-82c077edea9f"
Title="ListCustomSettings"
Description="Allow Custom Settings on any list"
Version="12.0.0.0"
Hidden="FALSE"
Scope="Web"
DefaultResourceFile="core"
xmlns="http://schemas.microsoft.com/sharepoint/">
<ElementManifests>
<ElementManifest Location="elements.xml"/>
</ElementManifests>
</Feature>

Now we will use the feature to implement a custom action.
Change the Elements.xml file of the Feature to look like:
<?xml version="1.0" encoding="utf-8" ?>

<Elements xmlns="http://schemas.microsoft.com/sharepoint/">
<CustomAction
Id="Custom.Configuration.ListCustomSettings"
GroupId="GeneralSettings"
Location="Microsoft.SharePoint.ListEdit"
RequireSiteAdministrator="FALSE"
Sequence="100"
Title="Custom Settings">
<UrlAction
Url="_layouts/ListCustomSettings/ListSetting.aspx?List={ListId}" />
</CustomAction>
</Elements>

The feature (as above) will give us a new hyperlink on the List Settings Page (ListEdit). It will look as follow:

The next step is to create a custom page which we can redirect to and on which we can mange the custom settings.

Add a .aspx page to your project with an associated .aspx.cs file.
(there is a little trick to adding this aspx page to the project... please see the footnote at the bottom of this post for step-by-step instructions)

Ensure that the two files are placed inside an appropriate solution folder within the LAYOUTS Folder. Also ensure that the name of the aspx file corresponds to the url used in the custom action definition (above).
<UrlAction Url="_layouts/ListCustomSettings/ListSetting.aspx?List={ListId}" />

Next we add controls, assembly references etc to our aspx page. I am not going into detail of each line of code as it is standard code.
Ensure your .aspx file look as follow:
(please take special note of the public token key as yours might be different)
<%@ Assembly Name="Microsoft.SharePoint, Version=12.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c" %>

<%@ Import Namespace="Microsoft.SharePoint" %>
<%@ Import Namespace="Microsoft.SharePoint.ApplicationPages" %>
<%@ Import Namespace="System.Data" %>
<%@ Register TagPrefix="SharePoint" Namespace="Microsoft.SharePoint.WebControls" Assembly="Microsoft.SharePoint, Version=12.0.0.0, Culture=neutral,PublicKeyToken=71e9bce111e9429c" %>
<%@ Register TagPrefix="Utilities" Namespace="Microsoft.SharePoint.Utilities" Assembly="Microsoft.SharePoint, Version=12.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c" %>
<%@ Register TagPrefix="wssawc" Namespace="Microsoft.SharePoint.WebControls" Assembly="Microsoft.SharePoint, Version=12.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c" %>
<%@ Register TagPrefix="wssuc" TagName="ToolBar" Src="~/_controltemplates/ToolBar.ascx" %>
<%@ Register TagPrefix="wssuc" TagName="ToolBarButton" Src="~/_controltemplates/ToolBarButton.ascx" %>
<%@ Register TagPrefix="wssuc" TagName="InputFormSection" src="~/_controltemplates/InputFormSection.ascx" %>
<%@ Register TagPrefix="wssuc" TagName="InputFormControl" src="~/_controltemplates/InputFormControl.ascx" %>
<%@ Register TagPrefix="wssuc" TagName="ButtonSection" src="~/_controltemplates/ButtonSection.ascx" %>
<%@ Page Language="C#" MasterPageFile="~/_layouts/application.master" AutoEventWireup="true" Inherits="ListConfig.ListConfig, ListCustomSettings,Version=1.0.0.0,Culture=neutral,PublicKeyToken=29d1ff49fe67cd5b" %>
<asp:Content ID="Content2" ContentPlaceHolderID="PlaceHolderPageTitle" runat="server">
Custom list config settings page
</asp:Content>
<asp:Content ID="Content3" ContentPlaceHolderID="PlaceHolderPageTitleInTitleArea" runat="server">
Custom list config settings
</asp:Content>
<asp:Content ID="Content1" ContentPlaceHolderID="PlaceHolderMain" runat="server">
<table width="50%" class="ms-propertysheet" cellspacing="0" cellpadding="0" border="0">
<tr>
<td class="ms-error">
<asp:Label ID="lblMessage" runat="server" EnableViewState="False" />
</td>
</tr>
</table>
<table width="50%" class="ms-propertysheet" cellspacing="0" cellpadding="0" border="0">
<tr><td class="ms-descriptionText"><asp:Label ID="LabelMessage" Runat="server" EnableViewState="False" class="ms-descriptionText"/></td></tr>
<tr><td class="ms-error"><asp:Label ID="LabelErrorMessage" Runat="server" EnableViewState="False" /></td></tr>
<tr><td class="ms-descriptionText"><asp:ValidationSummary ID="ValSummary" HeaderText="Errors" DisplayMode="BulletList" ShowSummary="True" runat="server"></asp:ValidationSummary></td> </tr> <tr> <td><img src="/_layouts/images/blank.gif" width="10" height="1" alt="" /></td></tr>
</table>
<table width="50%" border="0" cellspacing="0" cellpadding="0" class="ms-propertysheet">

<wssuc:InputFormSection Title="Key" runat="server">
<Template_Description>
<SharePoint:EncodedLiteral ID="EncodedLiteral1" runat="server" text="Specify a key for the entry." EncodeMethod='HtmlEncodeAllowSimpleTextFormatting'/>
</Template_Description>
<Template_InputFormControls>
<wssuc:InputFormControl LabelText="" runat="server">
<Template_control>
<wssawc:InputFormTextBox Title="Key" class="ms-input" ID="txtKey" Columns="35" Runat="server" MaxLength=255 />
</Template_control>
</wssuc:InputFormControl>
</Template_InputFormControls>
</wssuc:InputFormSection>

<wssuc:InputFormSection Title="Value" runat="server">
<Template_Description>
<SharePoint:EncodedLiteral ID="EncodedLiteral2" runat="server" text="Specify the value of the entry" EncodeMethod='HtmlEncodeAllowSimpleTextFormatting'/>
</Template_Description>
<Template_InputFormControls>
<wssuc:InputFormControl LabelText="" runat="server">
<Template_control>
<wssawc:InputFormTextBox Title="Value" class="ms-input" ID="txtValue" Columns="35" Runat="server" MaxLength=255 />
</Template_control>
</wssuc:InputFormControl>
</Template_InputFormControls>
</wssuc:InputFormSection>
<wssuc:ButtonSection runat="server" ShowStandardCancelButton="false">
<template_buttons>
<asp:PlaceHolder ID="PlaceHolderInsertUpdate" runat="server">
<asp:Button UseSubmitBehavior="false" runat="server" class="ms-ButtonHeightWidth" Text="Insert" id="cmdInsertUpdate" OnClick="cmdInsertUpdate_OnClick"/>
<asp:Button UseSubmitBehavior="false" runat="server" class="ms-ButtonHeightWidth" Text="Cancel" id="cmdInsertUpdateCancel" OnClick="cmdInsertUpdateCancel_OnClick"/>
</asp:PlaceHolder>
</template_buttons>
</wssuc:ButtonSection>
<br />
<br />
</table>
<SharePoint:SPGridView ID="grdEntries" runat="server" AutoGenerateColumns="false" Width="50%" AllowSorting="True" OnRowDeleting="grdEntries_RowDeleting" OnRowEditing="grdEntries_RowEditing" EnableViewState="false">
<AlternatingRowStyle CssClass="ms-alternating" />
</SharePoint:SPGridView>
<wssuc:ButtonSection runat="server" ShowStandardCancelButton="false">
<template_buttons>
<asp:PlaceHolder ID="PlaceHolder1" runat="server">
<asp:Button UseSubmitBehavior="false" runat="server" class="ms-ButtonHeightWidth" OnClick="cmdOK_OnClick" Text="OK" id="cmdOK" causesvalidation=false />
</asp:PlaceHolder>
</template_buttons>
</wssuc:ButtonSection>
<br />
<br />
<SharePoint:FormDigest ID="FormDigest1" runat="server" />
</asp:Content>

Now we need to code the ListConfig class which is the code-behind of our aspx page.
Open the ListSettings.aspx.cs in code view and add the following code:
using System;

using System.Data;
using System.Configuration;
using System.Collections;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using Microsoft.SharePoint;
using Microsoft.SharePoint.WebControls;
using Microsoft.SharePoint.Utilities;
using System.Xml;

namespace ListConfig
{
public partial class ListConfig : LayoutsPageBase
{
    private DataTable _dtEntries;
    private DataView _dvEntriesView;
    protected SPGridView grdEntries = new SPGridView();
    protected Label lblMessage = new Label();
    protected InputFormTextBox txtKey = new InputFormTextBox();
    protected InputFormTextBox txtValue = new InputFormTextBox();
}
}

Next, add a Page_Init event to the ListConfig class. In this event will we add two data columns and two command cokumns to our grid.
protected void Page_Init(object sender, EventArgs e)

{
BoundField objKeyField = new BoundField();
objKeyField.ItemStyle.Width = Unit.Percentage(30);
objKeyField.DataField = "Key";
objKeyField.HeaderText = "Key";
grdEntries.Columns.Add(objKeyField);

BoundField objValueField = new BoundField();
objValueField.DataField = "Value";
objValueField.HeaderText = "Value";
grdEntries.Columns.Add(objValueField);

CommandField objEditField = new CommandField();
objEditField.ShowEditButton = true;
objEditField.HeaderText = "Edit";
objEditField.ItemStyle.Width = Unit.Pixel(20);
objEditField.ButtonType = ButtonType.Image;
objEditField.EditImageUrl = "/_layouts/images/edit.gif";
grdEntries.Columns.Add(objEditField);

CommandField objDeleteField = new CommandField();
objDeleteField.ShowDeleteButton = true;
objDeleteField.HeaderText = "Delete";
objDeleteField.ItemStyle.Width = Unit.Pixel(20);
objDeleteField.ButtonType = ButtonType.Image;
objDeleteField.DeleteImageUrl = "/_layouts/images/delete.gif";
grdEntries.Columns.Add(objDeleteField);
}

Next, add a Page_Load event to the ListConfig class. In this event we set allowunsafeupdates=true and we bind the grid to data.
protected void Page_Load(object sender, EventArgs e)

{
SPContext.Current.Web.AllowUnsafeUpdates = true;
BindGrid();
}

Next, add a LoadData function to help load the data into the datatable. You will notice the important thing here is that we iterate through the RootFolder.Properties.Keys to get all custom settings for the current list, and then we load the data in to the datatable.
private void LoadData(string strSortOrder)

{
_dtEntries = new DataTable();
DataColumn objKeyColumn = new DataColumn();
objKeyColumn.DataType = Type.GetType("System.String");
objKeyColumn.ColumnName = "Key";
objKeyColumn.ReadOnly = true;
_dtEntries.Columns.Add(objKeyColumn);

DataColumn objValueColumn = new DataColumn();
objValueColumn.DataType = Type.GetType("System.String");
objValueColumn.ColumnName = "Value";
objValueColumn.ReadOnly = true;
_dtEntries.Columns.Add(objValueColumn);

foreach (string strKey in SPContext.Current.List.RootFolder.Properties.Keys)
{
if (strKey.StartsWith("vti_")) continue;
if (strKey.StartsWith("_reporting")) continue;
if (SPContext.Current.List.RootFolder.Properties[strKey] == null) continue;
if (SPContext.Current.List.RootFolder.Properties[strKey].ToString() == String.Empty) continue;

DataRow objRow = _dtEntries.NewRow();
try
{
objRow["Key"] = strKey;
}
catch
{
objRow["Key"] = "Error";
}
try
{
objRow["Value"] = SPContext.Current.List.RootFolder.Properties[strKey];
}
catch
{
objRow["Value"] = "Error";
}
_dtEntries.Rows.Add(objRow);
}
_dvEntriesView = _dtEntries.DefaultView;
_dvEntriesView.Sort = "[Key] asc";
}

Next, add a helper function to populate the grid:
private void BindGrid()

{
try
{
LoadData(String.Empty);
grdEntries.DataSource = _dvEntriesView;
grdEntries.DataBind();
}
catch (Exception err)
{
lblMessage.Text = lblMessage.Text + "Failed to bind data to page. Please try to reload the page.";
}
}

Add Event handlers for the grid behaviour:
public void grdEntries_RowDeleting(object sender, GridViewDeleteEventArgs e)

{
try
{
string strKey = grdEntries.Rows[e.RowIndex].Cells[0].Text;
strKey = SPHttpUtility.HtmlDecode(strKey);
if (SPContext.Current.List.RootFolder.Properties.ContainsKey(strKey))
{
SPContext.Current.List.RootFolder.Properties[strKey] = null;
SPContext.Current.List.RootFolder.Update();
}
BindGrid();
}
catch (Exception err)
{
lblMessage.Text = lblMessage.Text + err.Message + "\n";
}
}

public void grdEntries_RowEditing(object sender, GridViewEditEventArgs e)
{
string strKey = grdEntries.Rows[e.NewEditIndex].Cells[0].Text;
txtKey.Text = strKey;
txtKey.Enabled = false;
txtValue.Text = SPContext.Current.List.RootFolder.Properties[strKey].ToString();
}

public void grdEntries_Sorting(object sender, GridViewEditEventArgs e)
{
grdEntries.DataSource = _dvEntriesView;
grdEntries.DataBind();
}

Add a helper function to build a redirect url (which will be used when the form close):
private string GetRedirectUrl()

{
return SPContext.Current.Web.Url + String.Format("/_layouts/listedit.aspx?List={0}", Request.QueryString["List"]);
}

Add the Button Click Events which corresponds to the definition in the aspx file:
public void cmdOK_OnClick(object sender, EventArgs e)

{
SPUtility.Redirect(GetRedirectUrl(), SPRedirectFlags.UseSource, HttpContext.Current);
}

public void cmdInsertUpdate_OnClick(object sender, EventArgs e)
{
try
{
string strKey = txtKey.Text;
if (strKey.Length == 0)
{
throw new Exception("You must provide a key.");
}
if (strKey.Contains("&"))
{
throw new Exception("& is not allowed. You must provide an alternative name.");
}
string strValue = txtValue.Text;
if (strValue.Length == 0)
{
throw new Exception("You must provide a value.");
}
if (SPContext.Current.List.RootFolder.Properties.ContainsKey(strKey))
{
SPContext.Current.List.RootFolder.Properties[strKey] = strValue;
}
else
{
SPContext.Current.List.RootFolder.Properties.Add(strKey, strValue);
}
SPContext.Current.List.RootFolder.Update();
strKey = "";
strValue = "";
txtKey.Text = "";
txtKey.Enabled = true;
txtValue.Text = "";
BindGrid();
}
catch (Exception err)
{
lblMessage.Text = err.Message;
}
}

public void cmdInsertUpdateCancel_OnClick(object sender, EventArgs e)
{
txtKey.Text = "";
txtKey.Enabled = true;
txtValue.Text = "";
}

Override the OnUload event of the page to set the AllowUnsafeUpdates=false:
protected override void OnUnload(EventArgs e)

{
SPContext.Current.Web.AllowUnsafeUpdates = false;
}

WOW, it looks like a lot of code, but in fact, its not much!
Next, build your project and if all is successfull you are ready to test the outcome.

Go to your project properties and set the 'start browser with' setting to the target SP site url on which you want to test.

Save your project. Right click on your project, select WSPBuilder and then select "Build WSP" - keep an eye on the output pane to ensure that there are no problems. Once successful, right click on the project, select WSPBuilder and then select "Deploy".
Once done, go to the target SP site and refresh the site features list.
You will notice the following new site feature is available:

Activate the feature.
Go to any list or library and open the settings page.

You will notice the new Custom Action URL which we added:

When you click on the 'custom settings' custom action url you will be redirected to the new custom page:

On this page you can manage custom settings for the list.

There you go ! a very nice tool which can be used to store custom settings on any list or library.

Enjoy !!!

Note: Trick to add a aspx page to the project:
If you want to add a aspx page to the project you click on project and select "Add New Item..." but you will notice that the Web Form / .aspx item is not available to be selected.
When you want to add a aspx page with an associated aspx.cs file to the project there is a little trick that you need to do.
Open another instance of Visual Studio.
Select to create a new project and choose C# --> ASP.Net Web Application

Provide a projace name and click on "OK".
Once the project has been created you will see it contains a web form (aspx).
Open the Solution Explorer view --> right click and select "Open Folder in Windows Explorer".

From Windows Explorer copy the aspx file and aspx.cs file into your SharePoint project folder (where the solution of this tutorial project is located) and then in your project add an existing item and select the two files which you copied.

Silverlight in SharePoint - Option 2 - Custom Web Part Feature

2010-07-16T12:05:00.081+02:00

In two previous tutorials I showed how to create a simple Silverlight application, and how to use a Silverlight application inside SharePoint (WSS 3.0 or MOSS 2007) using a Content Editor Web Part.

There are a lot of conflicting and even unclear instructions on the web on how to achieve this.
Thank you Karine Bosch for the excellent post you made available. It is very well structured and helped me immensely in putting together this post for my team. The original blog post which a lot of my information come from can be found at http://karinebosch.wordpress.com/2009/07/17/integrating-silverlight-3-in-sharepoint-2007/

In this tutorial I will show how to develop a proper custom SharePoint web part feature which encapsulates the Silverlight application.

Please note that the example I give is very basic. It will be easy to make the web part more generic - you can add web part properties in which which the user can specify the height, width, and .xap file location. If you add the custom properties you will have a reusable Silverlight container web part.

Important:
This tutorial is for Silverligh 3 - there has been changes from Silverlight version 2 which you need to consider. (SL3 does not contain the System.Web.Silverlight.dll)

Prerequisites:
       Silverlight 3 Tools for Visual Studio (download here)
       SharePoint (WSS 3.0 or MOSS 2007)
       Visual Studio 2008

A working Silverlight application (see this tutorial to create one)

WSP Builder (to develop the SharePoint Web Part)

Lets Create our SharePoint Web Part:
Create a new Visual Studio 2008 project.
Select "WSPBuilder" from project type and "WSP Builder Project" from Templates.

Right-click on the project and add a new item. Select WSPBuilder from Categories and "Web Part Feature" from Templates.

Provide a description for the web part and set the Scope to "Site"

In the Solution Explorer, create a LAYOUTS folder under TEMPLATES and then create 2 new folders under the LAYOUTS folder. Name the 2 new folders "SL3" and "XAPS".
Inside the XAPS folder add an existing working Silverlight 3 application.
(see this tutorial to create one)

Now we have a structure to build our web part code and we have a Silverlight application which we can display in our web part.
Next we will add two Silverlight helper files. (which enables Web sites to create advanced Silverlight installation and instantiation experiences)

In Windows Explorer locate the Silverlight.js file from the C:\Program Files\Microsoft SDKs\Silverlight\v3.0\Tools folder.
Copy this file to the SL3 folder of your project.
(For more information on Silverligth.js please see this site.)

In Visual Studio Solution Explorer switch-on the "view all files" option, refresh your solution and then right click on Silverlight.js and select "Include in project". Alternatively use the "add to project" functionality.

Right Click on the SL3 folder and select "Add" --> "New Item"
Select Visual C# Items and Select JScript File.
Name the File SharePointSilverLightHelper.js

Once the file is added to your solution, open the file and add the following script to create a Silverlight application based on the silverlight.CreateObjectEx method:
function onSilverlightError(sender, args)
{
var appSource = "";
if (sender != null && sender != 0)
{
appSource = sender.getHost().Source;
}
var errorType = args.ErrorType;
var iErrorCode = args.ErrorCode;
var errMsg = "Unhandled Error in Silverlight Application " + appSource
+ "\n" ;
errMsg += "Code: "+ iErrorCode + " \n";
errMsg += "Category: " + errorType + " \n";
errMsg += "Message: " + args.ErrorMessage + " \n";
if (errorType == "ParserError")
{
errMsg += "File: " + args.xamlFile + " \n";
errMsg += "Line: " + args.lineNumber + " \n";
errMsg += "Position: " + args.charPosition + " \n";
}
else if (errorType == "RuntimeError")
{
if (args.lineNumber != 0)
{
errMsg += "Line: " + args.lineNumber + " \n";
errMsg += "Position: " + args.charPosition + " \n";
}
errMsg += "MethodName: " + args.methodName + " \n";
}
throw new Error(errMsg);
}

function createSL(divid, swidth, sheight, source, initparameters)
{
var pluginid = divid + "Plugin";
var divElement = document.getElementById(divid);
var altHTML = divElement.innerHTML;
if (swidth == null)
   {swidth='100%';}
if (sheight == null)
   {sheight='750px';
}
Silverlight.createObjectEx(
{ source: source,
    parentElement: divElement,
    id: pluginid,
    properties:
    {
     width:swidth,
     height:sheight,
     minRuntimeVersion:'2.0.31005.0'
  },
   events:
   {
    OnError: onSilverlightError
   },
   initParams: initparameters
   }
);
}

The solution file structure should look like this:

Save the Visual Studio solution.

Next, we will add the web part code to render the Silverlight application inside SharePoint.

Open your web part class (in this example SharePointSilverLightWebPart1.cs) in code view and remove all the unneccesary code so that the class is nice and clean:
using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using System.Web.UI;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using System.Web.UI.WebControls;
using Microsoft.SharePoint;
using Microsoft.SharePoint.WebControls;
using Microsoft.SharePoint.WebPartPages;
using System.Text;

namespace SharePointSilverLightWebPart1
{
   [Guid("848d4aec-5dd2-4b7d-a512-995191a627e8")]
   public class SharePointSilverlightWebPart1 :
          Microsoft.SharePoint.WebPartPages.WebPart
   {
   }
}

Add the following declaration inside the class:
private LiteralControl silverlightHost;

Add code to the OnPreRender event to register the javascript files.
protected override void OnPreRender(EventArgs e)
{
base.OnPreRender(e);
ClientScriptManager cs = Page.ClientScript
  if (!cs.IsClientScriptIncludeRegistered("sl_javascript"))
     cs.RegisterClientScriptInclude(this.GetType(),
     "sl_javascript", "/_LAYOUTS/SL3/Silverlight.js");
if (!cs.IsClientScriptIncludeRegistered("spsl_javascript"))
    cs.RegisterClientScriptInclude(this.GetType(),
    "spsl_javascript", /_LAYOUTS/SL3/SharePointSilverLightHelper.js");
}

Call the above javascript from within the CreateChildControls method:
protected override void CreateChildControls()
{
string xaplocation = null;
xaplocation = "_LAYOUTS/Xaps/SilverlightApplication1.xap";
Unit height = new Unit(500);
string slstring = string.Format("<script
  type=\"text/javascript\">createSL('silverlightHost', '{0}',
'{1}', '{2}', '{3}');</script>", height, height, xaplocation,
  "");
silverlightHost = new LiteralControl(string.Format("<div
id=\"silverlightHost\" style=\"width:100%; height:100%\"></div>
{0}", slstring));
this.Controls.Add(silverlightHost);
}

To test the solution, add a SharePoint site URL to the Debug settings of the project.

Save the project. Build the project. Use WSP Builder to "Build WSP" and then to "Deploy"
Navigate to the same SharePoint site in I.E. and go to Site Settings -->Site Collection Features. Activate your new feature.

Edit a web part page on your site and add the following web part:

See the new web part containing the Silverlight solution.

Enjoy !!

Silverlight in SharePoint Option 1 - CEWP

2010-07-13T21:21:00.006+02:00

This simple tutorial will illustrate how to embed a Silverlight application (.xap file) in SharePoint (WSS 3 or MOSS 2007) using a Content Editor web part.

Many thanks to my friend Hassan-Mia Salie for his contributions.

Prerequisites:
   Silverlight 3.0 Client
   SharePoint (WSS3 or MOSS)
   A Working Silverlight application (.xap file)
   (to see how to create a simple silverlight app check out this tutorial)

Lets Go:
Locate the web application folder of your SharePoint application.
Should be: C:\inetpub\wwwroot\wss\VirtualDirectories\1000\ ,where "1000" is the number of your SharePoint Web App IIS port.

Create a new “ClientBin” folder in the web application folder.

Open you SharePoint Web which exist within the same web application.

Edit a Page and add a CEWP.
Select to modify the shared web part and open the “Source Editor...”
Paste the following code.
(please note the name of your silverlight file - the file I used was called MySilverLightApp.xap.)

<object data="data:application/x-silverlight-2," type="application/x-silverlight-2" width="100%" height="100%">
<param name="source" value="ClientBin/MySilverLightApp.xap"/>
<param name="onError" value="onSilverlightError" />
<param name="background" value="white" />
<param name="minRuntimeVersion" value="3.0.40624.0" />
<param name="autoUpgrade" value="true" />
<a href="http://go.microsoft.com/fwlink/?LinkID=149156&v=3.0.40624.0" style="text-decoration:none">
<img src="http://go.microsoft.com/fwlink/?LinkId=108181" alt="Get Microsoft Silverlight" style="border-style:none"/>
</a>
</object>

Change the width and height from % to values.

<object data="data:application/x-silverlight-2," type="application/x-silverlight-2" width="400" height="400">
<param name="source" value="ClientBin/MySilverLightApp.xap"/>
<param name="onError" value="onSilverlightError" />
<param name="background" value="white" />
<param name="minRuntimeVersion" value="3.0.40624.0" />
<param name="autoUpgrade" value="true" />
</object>

Save the CEWP and refresh the page.... you will see you Silverlight app in SharePoint.

Enjoy !!