Dig SharePoint: 12/4/11

SharePoint 2010: Programatically Retrieve Credentials from the Secure Store Service

12/10/2011 Date: 1:57:00 AM Posted By SharePoint

SharePoint 2010′s Secure Store Service provides a way to map credentials and delegate access to remote resources. You may already be familiar with the MOSS 2007 Single Sign-on Shared Service, which was the former equivalent. The Secure Store Service integrates seemlessly with Business Connectivity Services (BCS), but it also features an API that can be taken advantage of within custom development projects. This makes the service an attractive option for storing sensitive configuration data such as connection strings, Web service credentials, etc.

The Secure Store Service allows us to create Target Applications which house sets of credentials. The two main types are Individual and Group applications, Individual meaning credentials are mapped to individual users, and Group meaning all users share the same set of credentials.

While the raw API isn't very intuitive, its design was likely intentional (additional security by obfuscation). With a little marshalling help from our interop library friends, we are able to retrieve credentials (provided the appropriate permissions to the target application).

To begin, we need to reference a couple of assemblies.

Microsoft.BusinessData.dll

C:\Program Files\Common Files\Microsoft Shared\Web Server Extensions\14\ISAPI\Microsoft.BusinessData.dll

Microsoft.Office.SecureStoreService.dll

C:\Windows\assembly\GAC_MSIL\Microsoft.Office.SecureStoreService\14.0.0.0__71e9bce111e9429c\Microsoft.Office.SecureStoreService.dll

And now for the reason you came to this post … the code

using System.Collections.Generic; using System.Linq; using System.Runtime.InteropServices; using System.Security; using Microsoft.BusinessData.Infrastructure.SecureStore; using Microsoft.Office.SecureStoreService.Server; using Microsoft.SharePoint;   namespace Trentacular.SharePoint.Util {     public static class SecureStoreUtils     {         public static Dictionary<string, string> GetCredentials(string applicationID)         {             var serviceContext = SPServiceContext.Current;             var secureStoreProvider = new SecureStoreProvider { Context = serviceContext };             var credentialMap = new Dictionary<string, string>();               using (var credentials = secureStoreProvider.GetCredentials(applicationID))             {                 var fields = secureStoreProvider.GetTargetApplicationFields(applicationID);                 for (var i = 0; i < fields.Count; i++)                 {                     var field = fields[i];                     var credential = credentials[i];                     var decryptedCredential = ToClrString(credential.Credential);                       credentialMap.Add(field.Name, decryptedCredential);                 }             }               return credentialMap;         }           public static string ToClrString(this SecureString secureString)         {             var ptr = Marshal.SecureStringToBSTR(secureString);               try             {                 return Marshal.PtrToStringBSTR(ptr);             }             finally             {                 Marshal.FreeBSTR(ptr);             }         }     } }

FluentSP – The Fluent SharePoint API

Date: 1:54:00 AM Posted By SharePoint

Download FluentSP 1.0 from Codeplex.com

Once you are doing a lot of SharePoint programming you know you often have to write lengthy pieces of code to implement simple tasks like querying SharePoint lists. Nowadays you can read a lot of fluent APIs or fluent interface. For instance, jQuery, a JavaScript library that had successfully introduced a fluent API to handle the hierarchical structure of the HTML documents.

Today, I want to introduce a small library I have developed, FluentSP, a modern fluent interface around the classic SharePoint 2010 API. By using FluentSP instead of the classic SharePoint API, you will be able to chain methods and act on sets of items of the underlying SharePoint objects.

What is a fluent API?
Checkout this CodeProject article A Look at Fluent APIs and the Wikipedia article Fluent interface.

To start into the fluent API you call the Use() method on SPSite, SPWeb, SPWebCollection or SPListCollection. The Use() method is implemented as an extension method that will return the entry facade object (see facade table below). Another entry point to the fluent API is the static class SP with its static methods CurrentSite, CurrentWeb, CurrentLists or RootWebLists.

SPContext.Current.Site.Use()... // => Returns the SPSiteFacade as entry point

// OR:
SP.CurrentSite()... // => Returns the SPSiteFacade as entry point

Using the entry facade instance you can start chaining the available facade methods as follows:

SP.CurrentSite().Web("Home").List("Tasks").Items().ForEach(i => // Do something with the item i of type SPListItem...);

// OR:
SP.CurrentSite()
.Web("Home")
.List("Tasks")
.Items()
.ForEach(i => // Do something with...);

Each facade object is actually wrapping an underlying data item, for instance the SPSiteFacade class is the fluent wrapper of the SPSite class. Depending on what kind of facade methods you are calling the method is returning either the current facade instance (e.g., ForEach() or Where()) or the method is returning a new child facade object (e.g. Items()). During the process of chaining methods in such a way you will build up a tree or hierarchy of facade instances. In order to step back to the parent or previous facade instance you need to call the End() method:

site.Use()
.RootWeb()
.Site()
.End() // Returns SPWebFacade as parent facade
.Site()
.End() // Returns SPWebFacade as parent facade
.End(); // Returns SPSiteFacade as parent facade

FluentSP is currently missing a number of possible useful methods, but you can easily extend the FluentSP API with custom facade classes and extension methods, see below and source code for implementation examples.

Samples

SPSite site = SPContext.Current.Site;

// ----------------------------

// Outputs titles of all lists of the root web where the list title starts with T
site.Use().RootWeb().Lists().Where(l => l.Title.StartsWith("T")).ForEach(l => Console.WriteLine(l.Title));

// Outputs titles of all lists of the root web where the list title ends with a ts (using RegEx)
site.Use().RootWeb().Lists("ts$").ForEach(l => Console.WriteLine(l.Title)).Count(out c);

// Outputs titles of all lists of the root web in ascending order where the starts with T
site.Use().RootWeb().Lists().Where(l => l.Title.StartsWith("T")).OrderBy(l => l.Title).ForEach(l => Console.WriteLine(l.Title));

// Outputs titles of all lists of the root web in descending order where the starts with T
site.Use()
.RootWeb()
.Lists()
.Where(l => l.Title.StartsWith("T"))
.OrderByDescending(l => l.Title)
.ForEach(l => Console.WriteLine(l.Title));

// ----------------------------

// Delete all items in the Members list, then add 7 new members and then select and output
// the titles of a few of the newly created items
site.Use()
.RootWeb()
.List("Members")
.Do(w => Console.WriteLine("Deleting all members..."))
.Items()
.Delete()
.End()
.Do(w => Console.WriteLine("Adding all members..."))
.AddItems(7, (i, c) => i["Title"] = "Member " + c)
.Items()
.Skip(2)
.TakeUntil(i => ((string)i["Title"]).EndsWith("6"))
.ForEach(i => Console.WriteLine(i["Title"]));

// ----------------------------

// Search for lists that are created by specific a user and depending on the results
// displays different messages by calling the IfAny or IfEmpty methods
site.Use()
.RootWeb()
.Lists()
.ThatAreCreatedBy("Unknown User")
.IfAny(f => f.ForEach(l => Console.WriteLine(l.Title)))
.IfAny(l => l.Title.StartsWith("M"), f => Console.WriteLine("Lists found that starts with M*"))
.IfEmpty(f => Console.WriteLine("No lists found for user"))
.End()
.Do(w => Console.WriteLine("---"))
.Lists()
.ThatAreCreatedBy("System Account")
.IfAny(f => f.ForEach(l => Console.WriteLine(l.Title)));

// ----------------------------

var items = new List<SPListItem>();

// Query with Skip and TakeUnitl methods
site.Use().RootWeb().List("Members").Items().Skip(2).TakeUntil(i => i.Title.EndsWith("5")).ForEach(i => { items.Add(i); Console.WriteLine(i.Title); });

// Query with Skip and TakeWhile methods
site.Use()
.RootWeb()
.List("Members")
.Items()
.Skip(2)
.TakeWhile(i => i.Title.StartsWith("Member"))
.ForEach(i => { items.Add(i); Console.WriteLine(i.Title); })
.End()
.Items()
.Where(i => i.Title == "XYZ")
.ForEach(i => { items.Add(i); Console.WriteLine(i.Title); });

// ----------------------------

// Adds new items using the Do method with the passed facade object
site.Use()
.RootWeb()
.AllowUnsafeUpdates()
.List("Members")
.Do((f, l) => {
for(int c = 1; c <= 5; c++)
f.AddItem(i => i["Title"] = "Standard Member #" + c);
})
.AddItem(i => i["Title"] = "Premium Member")
.Items()
.OrderBy(i => i.Title)
.ForEach(i => Console.WriteLine(i["Title"]));

Extensibility Samples

// This sample is using the ThatAreCreatedBy extension method defined in Extensions.cs to show how to extend the fluent API
site.Use()
.RootWeb()
.Lists()
.ThatAreCreatedBy("System Account", "jbaurle")
.Count(c => Console.WriteLine("Lists found: {0}", c))
.ForEach(l => Console.WriteLine(l.Title));

// This sample uses the new SPWebApplicationFacade extenion defined in SPwebApplicationFacade.cs to show how to extend the fluent API
site.WebApplication.Use()
.Sites()
.ForEach(i => Console.WriteLine(i.Url));

// This sample uses an alternative implementation for SPSiteFacade defined in SPSiteFacadeAlternate.cs to show how to extend the fluent API
site.WebApplication.Use().WithFirstSite().DoSomething();
site.Use<SPSiteFacadeAlternate<BaseFacade>>().DoSomething();

The custom method ThatAreCreatedBy which is used in the first query of the extensibility samples is implemented as follows:

static class Extensions
{
public static SPListCollectionFacade<TParentFacade> ThatAreCreatedBy<TParentFacade>(this SPListCollectionFacade<TParentFacade> facade, params string[] names)
where TParentFacade : BaseFacade
{
// NOTE: This sample uses the GetCollection method of the given facade instance to retrieve the current
// collection and adds the its query (see LINQ Deferred Execution). The Set method updates the
// underlying collection. The GetCurrentFacade method will then return the current facade to allow
// method chaining.

if(names.Length > 0)
facade.Set(facade.GetCollection().Where(i => names.Contains(i.Author.Name)));

return facade.GetCurrentFacade();
}
}

For more samples and details check out the source code you can download from Codeplex.

Built-In Facades and Methods

See Codeplex

Export SharePoint Task List Data To PDF Using A Templating System

Date: 1:10:00 AM Posted By SharePoint

A couple of times I had the situation where I needed to export SharePoint list data into a PDF file in a customized way. I wanted to use some kind of template technology to translate SharePoint list data into a PDF file. I was working with a text templating system called DotLiquid before (see also my post Implement A Generic Template Engine For SharePoint 2010 Using DotLiquid ).

It's a really simple and easy to use template engine for .NET. Another dependency is the PDF library ABCpdf8. You can download a trail version here. This library is very powerful in creating PDF files, especially in adding HTML content to a PDF document.

At the end of this post you can download a SharePoint 2010 sample solution that shows you how to create a new button called "Export to PDF" for each task list, see screenshot below:

This post is actually not describing all the implementation details. I currently have not the time to do this, but I still want to share this solution with you.

The SharePoint 2010 solution adds a new custom action called PDFCreationAction. This action will add a new ribbon button called "Export to PDF" next to the "Export to Excel" button. The button will be displayed for task lists only.

The command action will link to an ASPX-file called CreatePDF.aspx that is doing the actual work. The SharePoint list ID and will be passed as parameter. The Page_Load method of the web form is executing the template against the list data and then the HTML representation will get added to a PDF document using the ABCpdf8 library.

That's all!

Download Source

Implement A Generic Template Engine For SharePoint 2010 Using DotLiquid

Date: 1:04:00 AM Posted By SharePoint

During the process of creating a complex SharePoint application you often need to send mails and create text files based on SharePoint data elements like SPListItem or SPWeb. Mail templates for instance mostly contain specific list item data. It would be helpful sometimes if the text generation itself is template-driven.

This article shows how to implement a generic template manager based on the free DotLiquid templating system with SharePoint specific extensions. This allows you for example to iterate through all SharePoint lists available within a SiteCollection and render only details for lists which contain Task in their title:

<p>All task lists for the current web '{{SP.Web.Title}}' and site '{{SP.Site.Url}}'
<ul>
{% for list in SP.Lists %}
{% if list.Title contains 'Task' %}
<li><i>{{list.Title}}</i> with ID '{{Slist.ID|upcase}}' (<i>(Created:
{{list.Created|sp_format_date}})</i></li>
{% endif %}
{% endfor %}
</ul>
</p>
<p>All lists for current web '{{SP.Site.RootWeb.Title}}' created by the 'splists' tag
<ul>{% splists '<li>{0}</li>' %}</ul>
</p>

The screenshot below shows the result of the rendered template sample:

Of course the technique implemented in this article can also be used in conjunction with other technologies or applications, it's not only SharePoint related.

DotLiquid Template Engine

The DotLiquid template engine is a C# port of the Ruby's Liquid templating system and is available for .NET 3.5 and above. DotLiquid is open source and can be downloaded at dotliquidmarkup.org. The software is also available as NuGet package for Visual Studio.

The templating system includes features like variable, text replacement, conditional evaluation and loop statements that are similar to common programming languages. The language elements consists of tags and filter constructs.

The engine can also be easily extended by implementing and adding custom filters and/or tags. This article actually shows how to extend the DotLiquid and implement SharePoint specific parts.

The following sample shows a Liquid template file:

<p>{{ user.name | upcase }} has to do:</p>

<ul>
{% for item in user.tasks -%}
<li>{{ item.name }}</li>
{% endfor -%}
</ul>

Output markup is surrounded by curly brackets {{…}} and tag markup by {%…%}. Output markup can take filter definitions like upcase. Filters are simple static methods, where the first parameter is always the output of the left side of the filter and the return value of the filter will be the new left value when the next filter is run. When there are no more filters, the template will receive the resulting string.

There are a big number of standard filters available to use, but later on we will implement a custom filter method for SharePoint. The result of the above rendered template looks like:

<p>TIM JONES has to do:</p>

<ul>
<li>Documentation</li>
<li>Code comments</li>
</ul>

To pass variables and render the template you first need to parse the template and the then just call the Render method with the variable values:

string templateCode = @"<ul>
{% for item in user.tasks -%}
<li>{{ item.name }}</li>
{% endfor -%}
</ul>";

Template template = Template.Parse(templateCode);

string result = template.Render(Hash.FromAnonymousObject(new {
user = new User
{
Name = "Tim Jones",
Tasks = new List<Task> {
new Task { Name = "Documentation" },
new Task { Name = "Code comments" }
}
}}));

public class User : Drop
{
public string Name { get; set; }
public List<Task> Tasks { get; set; }
}

public class Task : Drop
{
public string Name { get; set; }
}

The User and Task classes inherit from the Drop class. This is an important class in DotLiquid. The next sections explains the class in more detail. It is out of scope of this article to discuss all the features for DotLiquid in detail. For more information please see the homepage of DotLiquid (dotliquidmarkup.org) or the website of the original creator of the Liquid template language at liquidmarkup.org. You will find there a lot of manuals and sample code.

Template Manager

The TemplateManager class is a wrapper over the DotLiquid template engine and provides SharePoint support. The class allows to cache parsed templates, to register tags and filters and render them using a top-level custom Drop class named SharePointDrop:

internal class TemplateManager
{
public Dictionary<string, Template> Templates { get; protected set; }

public TemplateManager()
{
Templates = new Dictionary<string, Template>();
}

public void AddTemplate(string name, string template)
{
if(string.IsNullOrEmpty(name))
throw new ArgumentNullException("name");
if(string.IsNullOrEmpty(template))
throw new ArgumentNullException("template");

if(Templates.ContainsKey(name))
Templates[name] = Template.Parse(template);
else
Templates.Add(name, Template.Parse(template));
}

public void RegisterTag<T>(string tagName) where T : Tag, new()
{
Template.RegisterTag<T>(tagName);
}

public void RegisterFilter(Type type)
{
Template.RegisterFilter(type);
}

public string Render(string nameOrTemplate, IDictionary<string, object> values)
{
Template template;

if(Templates.ContainsKey(nameOrTemplate))
template = Templates[nameOrTemplate];
else
template = Template.Parse(nameOrTemplate);

SharePointDrop sp = new SharePointDrop();

if(values != null)
{
foreach(KeyValuePair<string, object> kvp in values)
sp.AddValue(kvp.Key, kvp.Value);
}

return template.Render(new RenderParameters { LocalVariables =
Hash.FromAnonymousObject(new { SP = sp }), RethrowErrors = true });
}
}

The Render method is using the SharePointDrop class to support objects like SPListItem or SPListCollection. The Drop class as key concept of DotLiquid must be explained in detail. The DotLiquid template engine is focusing on making templates safe. A Drop is a class which allows you to export DOM like objects. DotLiquid, by default, only accepts a limited number of types as parameters to the Render method. These data types include the .NET primitive types (integer, float, string, etc.), and some collection types including IDictionary, IList and IIndexable (a custom DotLiquid interface).

If DotLiquid would support arbitrary types, then it could result in properties or methods being unintentionally exposed to template authors. To prevent this, DotLiquid templating system uses Drop classes that use an opt-in approach to exposing object data.

The code following shows the SharePointDrop implementation:

internal class SharePointDrop : Drop
{
Dictionary<string, object> _values;

public SharePointDrop()
{
_values = new Dictionary<string, object>();

if(SPContext.Current != null)
_values.Add("Site", SPContext.Current.Site);
if(SPContext.Current != null)
_values.Add("Web", SPContext.Current.Web);
if(SPContext.Current != null)
_values.Add("User", SPContext.Current.Web.CurrentUser);

_values.Add("Date", DateTime.Now);
_values.Add("DateISO8601",
SPUtility.CreateISO8601DateTimeFromSystemDateTime(DateTime.Now));

// TODO: Add more default values
}

public void AddValue(string name, object value)
{
if(string.IsNullOrEmpty(name))
throw new ArgumentNullException("name");

if(_values.ContainsKey(name))
_values[name] = value;
else
_values.Add(name, value);
}

public override object BeforeMethod(string method)
{
if(!string.IsNullOrEmpty(method) && _values.ContainsKey(method))
return DropHelper.MayConvertToDrop(_values[method]);

return null;
}
}

The SharePointDrop class main objective is to solve the problem of casting unsupported data types like SPListItem or SPListItemCollection and other SharePoint related types. Therefore the class is overriding the BeforeMethod method of the Drop class to analyse the requested variable value. If the variable is available in the value context the method will try to cast the data type to a known Drop type by calling the MayConvertToDrop method of the DropHelper class:

public static object MayConvertToDrop(object value)
{
if(value != null)
{
// TODO: Add your own drop implementations here

if(value is SPList)
return new SPPropertyDrop(value);
if(value is SPListCollection)
return ConvertDropableList<SPPropertyDrop, SPList>(value as ICollection);
if(value is SPListItem)
return new SPListItemDrop(value as SPListItem);
if(value is SPListItemCollection)
return ConvertDropableList<SPListItemDrop, SPListItem>(value as ICollection);
if(value is SPWeb)
return new SPPropertyDrop(value);
if(value is SPSite)
return new SPPropertyDrop(value);
if(value is SPUser)
return new SPPropertyDrop(value);
if(value is Uri)
return ((Uri)value).ToString();
if(value is Guid)
return ((Guid)value).ToString("B");
}

return value;
}

The SPListItemDrop class for instance is returning the value of the requested field:

internal class SPListItemDrop : SPDropBase
{
public SPListItem ListItem { get { return DropableObject as SPListItem; } }

public SPListItemDrop()
{
}

public SPListItemDrop(SPListItem listItem)
{
DropableObject = listItem;
}

public override object BeforeMethod(string method)
{
if(!string.IsNullOrEmpty(method))
{
StringBuilder sb = new StringBuilder();
string name = method + "\n";

for(int i = 0; i < name.Length; i++)
{
if(name[i] == '\n')
continue;
if(name[i] == '_')
{
if(name[i + 1] != '_')
sb.Append(' ');
else
{
i++;
sb.Append('_');
}
}
else
sb.Append(name[i]);
}

name = sb.ToString();

if(ListItem.Fields.ContainsField(name))
return DropHelper.MayConvertToDrop(ListItem[name]);
}

return null;
}
}

The method parameter (field name of the SPListItem) of the BeforeMethod method can contain underscores which are replaced by spaces. So, field names with spaces like Start Date of the Task item must be defined in the template as {{task.Start_Date}}.

The SPPropertyDrop class, also part of the solution of this article, is a generic Drop implementation which exposes all properties of an object and may cast them if needed into an Drop objects again. For implementation details see the source code.

Filters and Tags

The solution is also providing a custom filter and tag implementation. The filter called sp_format_date (see template above) is implemented by the method SPFormatDate and is calling the FormatDate method of the class SPUtility form the SharePoint API:

internal static class SPFilters
{
public static object SPFormatDate(object input)
{
DateTime dt = DateTime.MinValue;

if(input is string)
{
try
{
dt = SPUtility.ParseDate(SPContext.Current.Web, input as string,
SPDateFormat.DateOnly, false);
}
catch { }
}
else if(input is DateTime)
dt = (DateTime)input;

if(dt != DateTime.MinValue && dt != DateTime.MaxValue && SPContext.Current != null)
return SPUtility.FormatDate(SPContext.Current.Web, (DateTime)input,
SPDateFormat.DateOnly);

return input;
}
}

The custom tag named splists is returning a formatted list of all SPList object names of the current web (see template above):

internal class SPListsTag : Tag
{
string _format;

public override void Initialize(string tagName, string markup, List<string> tokens)
{
base.Initialize(tagName, markup, tokens);

if(string.IsNullOrEmpty(markup))
_format = "{0}";
else
_format = markup.Trim().Trim("\"".ToCharArray()).Trim("'".ToCharArray());
}

public override void Render(Context context, StreamWriter result)
{
base.Render(context, result);

if(SPContext.Current != null && !string.IsNullOrEmpty(_format))
{
foreach(SPList list in SPContext.Current.Web.Lists)
result.Write(string.Format(_format, list.Title));
}
}
}

Download Source Code | Download Article (PDF)

Dig SharePoint

SharePoint 2010: Programatically Retrieve Credentials from the Secure Store Service

FluentSP – The Fluent SharePoint API

Export SharePoint Task List Data To PDF Using A Templating System

Implement A Generic Template Engine For SharePoint 2010 Using DotLiquid

Search

Popular Posts

Blog Archive