Chaks' Corner

SharePoint 2010 Lists Improvements – List Lookups and Relationships

chakkaradeep — Fri, 06 Nov 2009 23:56:51 +1100

SharePoint 2010 brings in quite a few changes to Lists in SharePoint, especially in the lookup columns and enforcing relationships.

When you create a Lookup Column in SharePoint 2010 which fetches data from another List’s field, you can now add additional lookup fields and not just the identifier field!

Along with adding additional lookup fields, you can also enforce relationships so that it allows a cascade delete or restricts delete if a relationship still exists:

So, if there is a relationship associated, then you get this lovely error message when you try to delete an item (relationship behaviour configured to Restrict delete):

A Powerful Example to showcase List Relationships

Well, there isn’t much if I just show you the new options in lookup fields and relationships. Here is an example to show how powerful the relationships are in SharePoint 2010!

Projects and Employees List

So, I have two lists Projects and Employees list:

As you can see the Projects list has a lookup field Primary Contact which links to the Employees Fullname field. And the Employees list has a lookup field Project referring to the Project Title field.

If you click on a Project item, you get to see the project details, which is obvious:

Now, I would also like to see all the employees associated with this project. Given that we already have linked Projects and Employees list, this is certainly doable. You would go about asking any of your developers to build a web part that would do this job. With SharePoint 2010, its just plain simple with few steps :)

All we need to do is edit the default display form and add the Employees list!

In the SharePoint Ribbon (when you are on the List page, click on List in the Ribbon), select to edit the default display form:

This is the form that displays when you view an item.

This will open the default display form page in edit mode. Notice that the Ribbon now has Insert tab. Click on Insert and you will find the Related List button!

You can see the Employees list listed there! As it says, inserting this related lists web part will display related Employees items based on the Project lookup column! Go ahead and insert the list:

Below is the display form page with the related list web part added:

Save the page, and now, clicking on a Project item, you can see all the Employees associated with that particular project!

That wasn’t hard! Now, this is what I call a ‘killer-feature!’ :)

SharePoint 2010 and PowerShell – Made for Each Other!

chakkaradeep — Fri, 06 Nov 2009 23:13:49 +1100

One of the cool new features introduced in SharePoint 2010 are the new set of PowerShell Cmdlets for SharePoint. I have been working on those PowerShell Cmdlets for some time now (mainly configuring SharePoint service applications than development) and I am quite impressed to see how simple things are!

If you are using MOSS 2007, stsadm command is the tool you would use to configure and manage your SharePoint environment. The SharePoint community was the only resource if you were looking to leverage the PowerShell strength in MOSS 2007. From SharePoint 2010, though the stsadm command is still available, Microsoft recommends using the new PowerShell Cmdlets which are more efficient than using stsadm command. In fact, there is a PowerShell Cmdlet for everything and anything in SharePoint 2010!

Where to Begin?

There are two ways to start using the PowerShell Cmdlets:

1) From the SP2010 Management Shell

This opens a PowerShell Console session with all the cmdlets loaded.

2) Adding the Microsoft.SharePoint.PowerShell snap-in

You can also open a new PowerShell window, add the Microsoft.SharePoint.PowerShell snap-in to start using the cmdlets.

The Cmdlets

Now the real fun begins :)

There are more than 500 cmdlets in total! Well, I have to really appreciate Dmitry for putting up the available cmdlets in his blog! So, I wont repeat them here. Remember, that list is not final, but still it gives you an idea of what is possible now.

Some examples for Administrators

Though I see a major investment for developers too, the Administrators are the ones who are going to benefit a lot from these cmdlets.

Some examples are below. Please bear in mind that this is still in beta and things may change gradually as it reaches the final release:

[These cmdlets involves the use of new Service Applications introduced in SharePoint 2010]

Creating a new User Profile Service Application and User Profile Service Application Proxy

$upa=New-SPProfileServiceApplication 
-Name "Demo User Profile Service" 
-ApplicationPool "SharePoint Web Services Default" 
-MySiteHostLocation "http://demo2010a/my" 
-MySiteManagedPath "my/personal" 
-ProfileDBName "DEMO2010A_ProfileDB" 
-ProfileSyncDBName "DEMO2010A_SyncDB" 
-SocialDBName "DEMO2010A_SocialDB" -Verbose

New-SPProfileServiceApplicationProxy 
-Name "Demo User Profile Service Proxy" 
-ServiceApplication $upa 
-DefaultProxyGroup

Note that this is also attaching existing databases for Profile, Social and Sync databases. This is useful when you are restoring the Users’ Profile, MySites databases and want to create a user profile service application based on those restored databases. If you dont supply any values for database, it should create a new databases.

Creating a new Secure Store Master Key & Application Key

The Secure Store Service Application manages the secure store accounts which we can use in many other service applications like Visio Services, Performance Point Services etc., for setting up authentication with external data sources. This initially requires a Master Key and Application Key to be generated based on which you can now create target applications IDs and set credentials and permissions. So below is the PowerShell script to create these initial keys:

First, let us get a reference to the secure store service application:

$secureStore=Get-SPServiceApplicationProxy | 
where { 
$_.GetType()
.Equals([Microsoft.Office.SecureStoreService.Server.SecureStoreServiceApplicationProxy
]) }

Now, we can create the Master Key:

Update-SPSecureStoreMasterKey 
-ServiceApplicationProxy $secureStore.Id 
-Passphrase "passPhrase1"

And the Application Key:

Update-SPSecureStoreApplicationServerKey 
-ServiceApplicationProxy $secureStore.Id
-Passphrase "passPhrase1"

Setting the unattended account for Performance Point Services

Below is the PowerShell script to set the unattended account for authenticating with external data sources. Note how it also uses PSCredential object to get the user credentials:

Get-SPPerformancePointServiceApplication | 
Set-SPPerformancePointSecureDataValues 
-DataSourceUnattendedServiceAccount 
(New-Object System.Management.Automation.PSCredential "username", 
(ConvertTo-SecureString "password" -AsPlainText -Force))

I have to agree the examples above are bit advanced, but you can see the power of PowerShell here. If you are going to do these in the SharePoint UI, its going to take at least 5-10 minutes, but with PowerShell its going to take only seconds!

But for now I will leave you to explore the possibilities of the other PowerShell cmdlets like:

1) Get-SPWeb

2) Get-SPWebApplication

3) Get-SPSite

4) Get-SPFarm

And some link love to Zach’s excellent blog posts:

1) PowerShell 2010: Basic Discovery

2) PowerShell 2010: Basic SharePoint Cmdlets

3) SP 2010: Intro to PowerShell Part 3

I will post more cmdlets as I start using them here in my blog :)

Office DevCon Session Downloads

chakkaradeep — Fri, 06 Nov 2009 09:02:08 +1100

As promised, you can download my Office DevCon session slides and project below:

SharePoint 2010: Content Type Hubs – Publish and Subscribe to Content Types

Admin — Tue, 03 Nov 2009 14:19:00 +1100

MOSS 2007

Say for example you have a Site Collection Web Application1 and you have created a series of content types to use. Now, you create Web Application2 and find the necessity to reuse the content types created in Web Application 1. There is no way you could share or reference those content types created in Web Application1 in Web Application2. The only way possible is to create or write an application which would install those content types. This situation is pretty common in large organizations. This can be even considered for exposing base content types you use across multiple web applications in the farm.

Below is the diagram representing the above chaos:

SharePoint 2010

SharePoint 2010 now introduces a new feature called Content Type Hubs.Content Type Hub is a central location where you can manage and publish your content types – so now web applications can subscribe to this hub and pull down the published content types from the hub. Even receive updates on the published content types!

As you can see, the content type hub is exposed to every web application using the Metadata Service Application. So, as long as the web applications use the same Metadata Service Application, the content types will be pushed to those subscribed web applications.

Configuring The Content Type Hub

This is pretty simple.

1) Create the web application and the root site which you want it to be the Hub

2) In the Managed Metadata Service Application (under Central Administration | Application Settings | Service Applications )properties, you can set the Content Type Hub

3) In the Managed Metadata Service Connection, we explicitly tell to consume content types from the hub

4) Now, we can go to our content type hub site, create content types and you should see Manage content type publishing option

5) And publish the same

6) This will publish the content types

Timer Jobs

In order to receive the published content types immediately, you can go and run two timer jobs immediately:

1) Content Type Hub

2) Content Type Subscriber (of the web application which is going to receive the content types updates)

Published Content Types

After running the timer jobs, the content types should be published. Go to your Site Settings | Site Collection Administration | Content Type Publishing

You can see all the published content types here :)

Remember, as long as the Web Application use the same Metadata Service Application the content type hub is using, it can receive the content types from the hub.

Very neat and useful feature from the SharePoint team!

More posts will follow in the future once we start using it in the real world projects. Big thanks to Steve for his blog post on this.

Workflow Support for External Lists

Admin — Sun, 01 Nov 2009 14:49:00 +1100

If you are already playing with SharePoint 2010 and BCS, you would have noticed that there is no option to associate workflows for external lists. Many users have asked me whether these external list support workflows, so here is the answer from Tom Rizzo, SharePoint Senior Director, at the MSDN forums:

You can associate a workflow as a custom action for your External List in SPD. You probably (and I'll have to double check but I'm 99% sure) can't have a workflow fire by default against an external list since the workflow engine won't see things changing in the backend system.

Now, workflow is pluggable in 2010 so you might be able to plug in your own event provider into our workflow engine and watch the backend yourself. I haven't tried to do that yet so I don't know if it's feasible but it's something to take a look at if you want automatic workflow start but definitely clicking a button on the ribbon on an external list and triggering a workflow is supported.

Rather than creating an external list, you may want to instead create a SharePoint list with external columns so you get more SharePoint native features.
Hope this helps.

Tom

SharePoint 2010: Visio Services

Admin — Wed, 28 Oct 2009 01:01:00 +1100

Microsoft introduced Visio Services in SharePoint Server 2007. With SharePoint 2010, Microsoft has taken the Visio Services to the next level by allowing rendering of Visio diagrams and charts within the browser. Users can now use the out of the box Visio web parts to render the Visio diagrams and bring in the seamless integration of business intelligence between Visio, SharePoint and back end data.

Let me show you an example:

Lets create a simple Visio diagram which fetches values from external data:

This diagram is using the SupplyChain SQL database and the Suppliers table:

I can now save this as a Visio Web Diagram (.vdw) and upload to a document library in my Business Intelligence site.

Now, I can go to my dashboard and insert the Visio web diagram using the Visio Web Access web part.

This will add the Visio Web Access web part to the dashboard page where you can specify the Visio file to render:

Below is the rendered Visio web diagram in the web part:

You can see that the external data is also fetched in the diagram!

Notice there is also an option to enable refresh!

You can pan and also zoom into the diagram using the zooming controls (its very interactive!):

You can configure some of the default behaviour of the web part from its web part options pane:

The Real Deal

Lets go to SQL and change the Assembly Time value for the Bevel Assembly from 45 to 55

Lets go back to our dashboard page and refresh the Visio web diagram:

We now have the updated value!

Configuring Visio Services

The Visio Services is managed by the Visio Graphics Service service application (Central Administration | Application Management | Manage Service Applications)

SharePoint 2010: Sandboxed Solutions

Admin — Tue, 27 Oct 2009 18:48:00 +1100

SharePoint 2010 introduces new feature called Sandboxed Solutions. These sandboxed solutions are nothing but .wsp packages which has limited access to resources and runs isolated alongside other processes. Sandboxed solutions will not be able to make updates beyond the scope of the current site. You are also limited in performing farm level and web application level changes.

But Why Sandboxed Solutions?

Today, in SharePoint Server 2007, solutions are deployed in the farm level though you can activate features per web application or site. There is no proper way you can centrally manage/administer these solutions in a shared environment per web application or site. With sandboxed solutions, administrators can now allocate quotas, monitor the usage and also prevent excessive usage of resources by the solution. But yes, you are limited in the functionality what the solution can access, but as long as the solution scope is not beyond the site level, it is always better to build sandboxed solutions.

Surprisingly, Sandboxed solutions are going to play a major role in Microsoft Online Services very soon :)

Building a Sandboxed Solution

Building a Sandboxed solution is as simple as building a normal SharePoint application (Web Part, User Control etc.,).

Refer the following MSDN Article to find out more about Sandboxed Solutions. From MSDN:

The following capabilities and elements are available in sandboxed solutions:

List definitions

List instances

Onet.xml

WebTemplate Feature element instead of Webtemp.xml

Content Types/Fields

Navigation

Module/files

Feature callouts

Web Parts derived from WebPart

Event receivers

SPItemEventReceiver

SPListEventReceiver

SPWebEventReceiver

Custom Actions

Workflows

The following capabilities and elements are not available in sandboxed solutions:

Custom Action groups

HideCustomAction element

Content Type Binding

Web Application-scoped Features

Farm-scoped Features

Sandbox Services

Sandbox solutions are available as a farm service that you can start/stop:

There are three services required for Sandboxed solutions to run:

You can also use stsadm command to start/stop the user code service application:

stsadm -o provisionservice -action start -servicetype +

"Microsoft.SharePoint.Administration.SPUserCodeService, Microsoft.SharePoint, Version=14.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c" +

-servicename "SPUserCodeV4"

Configuring Quotas and Resource Usage

Administrators can create and configure quotas for site collection from the Central Administration.

The settings are available under Application Management | Site Collections

Clicking on Specify quota templates will allow administrators to create/edit quota templates and specify the maximum usage based on points.

In the Configure quotas and locks, administrators can assign the quota to a site collection.

Building a simple Sandboxed Web Part Solution

Create a new Empty SharePoint Project

In the SharePoint Configuration Wizard, choose to Deploy as sandboxed solution

Visual Studio will create the necessary project files

Add a new Web Part item to the project

Here is my code inside the web part class

[ToolboxItemAttribute(false)]
public class MySBWebPart : WebPart
{
    ListBox lstProjects = new ListBox();
    
    public MySBWebPart()
    {
    }

    protected override void CreateChildControls()
    {
        SPLinqDataContext context = new SPLinqDataContext("http://demo2010a");

        var projects = context.Projects;
        foreach (var project in context.Projects)
        {
            lstProjects.Items.Add(project.Title);   
        }

        context.Dispose();

        Controls.Add(lstProjects);
    }
}

Very simple code, just pulling all the projects from a Projects list. Note that I am also using Linq to SharePoint

Build and Deploy the solution

The solution will now be available in the Solutions Gallery in your site (Site Actions->Site Settings and under Galleries)

You can find all the user solutions there

You can also notice the other info like resource usage and total server resources.

Now, you can add the sandboxed web part to your site page. Below is a screenshot of the sandboxed web part

SharePoint 2010: Extending a SharePoint Node in Server Explorer

Admin — Thu, 22 Oct 2009 17:01:00 +1100

SharePoint Server Explorer is a new addition to Visual Studio 2010 along with the Visual Studio Tools for SharePoint.

It is a very good tool if you want to browse the contents (site columns, content types, features etc.,) of the SharePoint site from Visual Studio. By default, it doesn’t do nothing much than showing what are available in the site.

As you can see, the context menu has very fewer items. Below is the Properties pane for the Holds list in the screenshot. The properties are stored in Annotations. To understanding what Annotations are, it is best to consider them as a Class with Properties. Those properties is what you see in the Properties pane below.

Again, its read only.

Can I Extend?

So, the next obvious question you would ask yourself (if you are a SharePoint developer) is – Can I extend this and add my own commands or nodes to the SharePoint Server Explorer?

Yes, you can extend the SharePoint Server Explorer to:

1) Create new nodes

2) Extend existing nodes

Give me an example?

Lets take the Features node

The Features node displays all the active features in the site. If you right click on a feature, you get very less options

How cool would be to add Deactivate option to the context menu and deactivate the selected feature? :)

[ By the way, the above screenshot is an actual extension built and not a Photoshop trick :) ]

Understanding the SharePoint Server Explorer

Before you start writing an extension, you should get to know the different types of SharePoint Server Explorer nodes.

The node that we are interested in is the FeatureNode.

Getting Started

MSDN has excellent articles explaining how to extend the Visual Studio Tools for SharePoint

Here is a pictorial representation of what we would be doing:

1. Create a class that implements IExplorerNodeTypeExtension

2. Handle the events

3. Access the properties of that node using Annotations

4. Perform SharePoint operations using Client Object Model

Step 1

Create a Windows Class Library project and add references to

Microsoft.VisualStudio.SharePoint
Microsoft.VisualStudio.SharePoint.Explorer.Extensions
System.ComponentModel.Composition

Step 2

Create a class and implement IExplorerNodeTypeExtension:

internal class FeatureNodeExtension : IExplorerNodeTypeExtension
{

}

Step 3

As we are interested in adding an item to the context menu, handle the NodeMenuItemsRequested. This is done in the Initialize method:

public void Initialize(IExplorerNodeType nodeType)
{
   nodeType.NodeMenuItemsRequested += 
           new EventHandler<ExplorerNodeMenuItemsRequestedEventArgs>
                                        (nodeType_NodeMenuItemsRequested);
}

And here is the event handler:

void nodeType_NodeMenuItemsRequested(object sender, ExplorerNodeMenuItemsRequestedEventArgs e)
{       
    IMenuItem deactivateMenu = e.MenuItems.Add("Deactivate");
    deactivateMenu.Click += 
             new EventHandler<MenuItemEventArgs>(deactivateMenu_Click);
}

We add the new menu item in the event handler above and also handle its own click event.

Step 4

As we want to deactivate a feature, we need to know the Feature Definition Id. They are already available in the Properties pane for a feature:

To access the Properties we need to access it via the Annotations object. Here is the code to access the Feature properties:

IFeatureNodeInfo fn = e.Node.Annotations[typeof(IFeatureNodeInfo)] as IFeatureNodeInfo;
definitionId = fn.Id;
featureName = fn.Name;

Next thing is to get the site at which this feature is installed. As the Server Explorer has already established the connection to the site, we can get it from its current context.

IExplorerNodeContext siteContext = e.Node.Context;

Here is how my event handler looks:

void nodeType_NodeMenuItemsRequested(object sender, ExplorerNodeMenuItemsRequestedEventArgs e)
{           
    siteContext = e.Node.Context;
    IFeatureNodeInfo fn = e.Node.Annotations[typeof(IFeatureNodeInfo)] as IFeatureNodeInfo;
    definitionId = fn.Id;
    featureName = fn.Name;           
   
    IMenuItem deactivateMenu = e.MenuItems.Add("Deactivate");
    deactivateMenu.Click += new EventHandler<MenuItemEventArgs>(deactivateMenu_Click);
}

Step 5

We can now write code to deactivate the feature in the new menu item’s event handler using the Client Object Model:

void deactivateMenu_Click(object sender, MenuItemEventArgs e)
{
    if (MessageBox.Show(confirmationMessage,String.Format("Deactivate {0} feature",featureName), 
                        MessageBoxButtons.YesNo, 
                        MessageBoxIcon.Exclamation) == DialogResult.Yes)
    {
        IExplorerNode parentFeatureNode = e.Owner as IExplorerNode;
        IExplorerNode featureNode = parentFeatureNode.ParentNode;

        ClientContext clientContext = new ClientContext(siteContext.SiteUrl.AbsoluteUri);
        Web site = clientContext.Web;
        FeatureCollection siteFeatures = site.Features; 
       
        clientContext.Load(site, s => s.Title, s => s.Features);
        siteFeatures.Remove(definitionId, false);

        clientContext.ExecuteQuery();

        clientContext.Dispose();

        featureNode.Refresh();
    }
}

Very simple indeed. Query and get only the Web and Features object, and then remove (deactivate) the feature from the site.

You can also do this asynchronously using the Asynchronous Pattern for Client OM.

Deploying the Extension

To deploy the extension, we need to include it in a .vsix package.

You can use the VSIX template to create the .vsix package.

Include the extension in the manifest file.

Chose the content as MEF Component and select the extensions project as your source.

Build the project to generate the .vsix package and install the package.

‘Deactivate Extension’ for FeaturesNode done

And here is our menu item in the context menu:

When you click on it, you will get a confirmation message:

Clicking Yes will deactivate the feature and refresh the Features node.

You can download the source code and VSIX package below:

SharePoint 2010: Asynchronous Query Pattern for Client Object Model

Admin — Wed, 21 Oct 2009 16:44:00 +1100

In the SharePoint 2010: Getting Started With Client Object Model blog post, we built a simple SharePoint console application using Client OM. We queried synchronously which is good for simple operations, but you would like to query asynchronously too if you intend to have more queries to the SharePoint server. Below are simple yet easy steps to query asynchronously.

Step 1 – Create a new class for our Asynchronous operations

Create a new class ClientOMAsync

Step 2 – Create a delegate for our Query

public class ClientOMAsync
{
    delegate void ExecuteAyncQuery();
}

Add the required variables you want to use

Step 3 – Declare our variables

public class ClientOMAsync
{
    delegate void ExecuteAyncQuery();

    Web site;
    ClientContext context;
}

Step 4 – Create the Run method

public void Run()
{
    context =
        new ClientContext(http://<your-site>);
    site = context.Web;
    context.Load(site, s => s.Title);
    ExecuteAyncQuery executeQueryAsync = new ExecuteAyncQuery(context.ExecuteQuery);
    executeQueryAsync.BeginInvoke(callback, null);
}

Pretty basic Asynchronous programming model and notice again that we are fetching only the Title property.

Step 5 – Create our Callback method

void callback(IAsyncResult arg)
{
    Console.WriteLine("Aync Callback!");



    Console.WriteLine("Title before changing: {0}",site.Title);
    site.Title = site.Title + " Async";
    site.Update();



    context.ExecuteQuery();



    Console.WriteLine("Title after the change: {0}",site.Title);
    Console.WriteLine("Query completed!");
}

Step 6 – Perform the Asynchronous Client OM

Below is the code block that starts this asynchronous query operation from the Main method in the console application

static void Main(string[] args)
{
    ClientOMAsync clientOMAsync = new ClientOMAsync();
    clientOMAsync.Run();



    Console.WriteLine("This is end of the Main program");           
    
    Console.Read();
}

And here is our Output:

Below is the full code for ClientOMAsync class:

public class ClientOMAsync
{
    delegate void ExecuteAyncQuery();

    Web site;
    ClientContext context;

    public void Run()
    {
        context =
            new ClientContext("http://demo2010a");
        site = context.Web;
        context.Load(site, osite => osite.Title);
        ExecuteAyncQuery executeQueryAsync = new ExecuteAyncQuery(context.ExecuteQuery);
        executeQueryAsync.BeginInvoke(callback, null);
    }

    void callback(IAsyncResult arg)
    {
        Console.WriteLine("Aync Callback!");

        Console.WriteLine("Title before changing: {0}",site.Title);
        site.Title = site.Title + " Async";
        site.Update();

        context.ExecuteQuery();

        Console.WriteLine("Title after the change: {0}",site.Title);
        Console.WriteLine("Query completed!");
    }
}

SharePoint 2010: Getting Started With Client Object Model

Admin — Wed, 21 Oct 2009 15:55:00 +1100

Along with the Server Object Model, SharePoint 2010 introduces new set of API called Client Object Model

Refer to my blog post SharePoint 2010: Introducing the Client Object Model to get to know more about Client Object Model.

The Client Object Model (OM) is a new programming interface for SharePoint 2010 where code runs on a user’s client machine against a local object model and interacts with data on the SharePoint Server.

Lets get started on our ‘Hello Word’ Client Object Model console application.

Step 1 – Reference the Client Object Model

You need to reference two dlls which are available at C:\Program Files\Common Files\Microsoft Shared\Web Server Extensions\14\ISAPI

1. Microsoft.SharePoint.Client

2. Microsoft.SharePoint.Client.Runtime

Add the using namespace for Microsoft.SharePoint.Client

using Microsoft.SharePoint.Client;

Step 2 – Create the Client Context

[ We will use the Main function to write our piece of code ]

You need to first create a context to the SharePoint site:

ClientContext context = 
       new ClientContext(http://<your-site>);

Step 3 – Create Your Query

Here is the next block of code, explanations will follow below:

Web site = context.Web;
context.Load(site, s => s.Title);

As you can see, we are querying for what we require and nothing else will be returned. In our code, we pass the site to the context, but say we want to query only the property Title.

Step 4 – Execute Your Query

Below is the code to execute the query:

context.ExecuteQuery();

The ExecuteQuery() method is a synchronous method call.

Step 5 – The Output

Below is the output:

Another Query Example

ListCollection lists = site.Lists;
IEnumerable<SP.List> listsCollection =
    context.LoadQuery(lists.Include(
                              l => l.Title,
                              l => l.Id));

The above code queries all the Lists in the site, but only returns the Title and the Id properties.

In the next post, we will see how we can query asynchronously.