Bob's SharePoint Bonanza

Deploying site columns and content types to sharepoint webs

Robert Fridén — Mon, 17 Dec 2007 15:56:00 GMT

Hi everyone!

It's been a long time since my last (and first) post. Mostly because my job is keeping me insanely busy these days, but also since there are so many excellent SharePoint bloggers out there that it's not every day you discover something worth blogging that someone hasn't already written about. But last week i ran into a problem when we were about to create some features and site definitions to deploy a portal for one of our customers that I thought maybe would be of interest to other people.

The portal consisted of one site collection on the top level and several levels of webs underneath. On some of the subwebs we had created site columns with lookups to lists on that web and based content types on them. We knew that we could deploy content types and site columns using the feature framework and we tried to do just that only to discover that stsadm would spurt out nasty error messages telling us that features with web scope cannot be used to deploy that type of content.

"No Problem", I thought, "I'll just create a small app that uses the API to add them instead". But that proved to be easier said than done since the API require your content type to inherit from existing content types and when you do, it will create new GUIDS for them which just cut it for us. So what I ended up doing (once again) was to reverse engineer selected parts of SharePoint and trick it into adding content types and site columns on webs using specific GUIDs and now I'll tell you how to do the same.

The first step for me was to get the information about the content types and site columns out of our development environment so I could move it from one machine to another. For this I created a small console application. If I had more time I would probably made and STSADM extension out of it, but I'll leave that as an exercise for the reader .

The application iterates through the entire site and generates an XML file with each web in it's own node to keep the information structured and so that I'll be able to read out which web each field belongs to when I import it later. This time I was in luck since the SPField object in the Fields collection on the SPWeb object actually has a property called "SchemaXml" which contains the definition of the field.

The SchemaXml property of a column looks something like this:

But unfortunately, look-up columns refer to the source lists and webs by GUID (the List and WebId attributes above) which means that there's no way we can just import this XML into another farm and expect everything to work. We have to examine the schema XML and fiddle with it a little by inserting a little extra information to help us determine the correct GUIDs during import.

So let's load up the XML in an XMLDocument in the loop that iterates through all the site columns in the web:

XmlDocument doc = new XmlDocument();
doc.LoadXml(field.SchemaXml);

And then check if the field has a "List"-attribute and if it does, append a "ListName"-attribute with the name of the list that the GUID points to:

// Fix List GUID
if (doc.DocumentElement.Attributes["List"] != null && doc.DocumentElement.Attributes["List"].Value.StartsWith("{"))
{
Guid listId = new Guid(doc.DocumentElement.Attributes["List"].Value);
XmlAttribute listNameAttribute = doc.CreateAttribute("ListName");
listNameAttribute.Value = web.Lists[listId].Title;
doc.DocumentElement.Attributes.Append(listNameAttribute);
}

Then check if there's a WebId attribute and give it a similar treatment by adding a WebName attribute:

// Fix Web GUID
if (doc.DocumentElement.Attributes["WebId"] != null)
{
Guid webId = new Guid(doc.DocumentElement.Attributes["WebId"].Value);
XmlAttribute webNameAttribute = doc.CreateAttribute("WebName");
using (SPWeb sourceWeb = web.Site.OpenWeb(webId))
{
webNameAttribute.Value = sourceWeb.ServerRelativeUrl;
}
doc.DocumentElement.Attributes.Append(webNameAttribute);

Now we have fully importable look-up site column XML! Next, let's export some content types!

Here's where I stumbled upon my first hurdle in my endeavor. SPContent type doesn't have any SchemaXml property! But after some research with Reflector I found out that SPContentType has an internal method called "SaveCore" that takes an XmlTextWriter and exports the content type definition to XML which is just what we need! So let's write a helper method that calls SaveCore on an SPContentType object and returns the exported XML using reflection:

private static string GetInternalSchema(SPContentType ctype)
{
MethodInfo saveCoreMethod = ctype.GetType().GetMethod(
    "SaveCore",
    BindingFlags.NonPublic | BindingFlags.Instance,
    null,
    new Type[] { typeof(XmlTextWriter), typeof(bool), typeof(bool) },
    null);
StringBuilder sb = new StringBuilder();
XmlTextWriter xwtr = new XmlTextWriter(new StringWriter(sb, CultureInfo.InvariantCulture));
saveCoreMethod.Invoke(ctype, new object[] { xwtr, false, false });
xwtr.Flush();
xwtr.Close();
return sb.ToString();
}

Here's an example of what this method writes for one of my content types:

<ContentType ID="0x01040074079E5E8E5DA5419F1CE8300AA67B68" Name="MyContentType" Group="MyContentTypes" Version="2">
<Folder TargetName="_cts/MyContentType" />
    <FieldRefs>
      <FieldRef ID="{c042a256-787d-4a6f-8a8a-cf6ab767f12d}" Name="ContentType" />
      <FieldRef ID="{fa564e0f-0c70-4ab9-b863-0177e6ddd247}" Name="Title" Required="TRUE" ShowInNewForm="TRUE" ShowInEditForm="TRUE" />
      <FieldRef ID="{7662cd2c-f069-4dba-9e35-082cf976e170}" Name="Body" />
      <FieldRef ID="{3805f629-5035-4a13-9362-8d1b216bbc05}" Name="CustomColumnHere" />
      <FieldRef ID="{51d39414-03dc-4bd0-b777-d3e20cb350f7}" Name="PublishingStartDate" />
      <FieldRef ID="{a990e64f-faa3-49c1-aafa-885fda79de62}" Name="PublishingExpirationDate" />
    </FieldRefs>
    <XmlDocuments>
      <XmlDocument NamespaceURI="http://schemas.microsoft.com/sharepoint/v3/contenttype/forms">
        <FormTemplates xmlns="http://schemas.microsoft.com/sharepoint/v3/contenttype/forms">
          <Display>ListForm</Display>
          <Edit>ListForm</Edit>
          <New>ListForm</New>
        </FormTemplates>
      </XmlDocument>
    </XmlDocuments>
</ContentType>

Ahhh. I love .NET

Anyway! Let's move on the next step: Importing the site columns!

Before we can feed SharePoint the exported Schema XML for the columns, we have check each column for the ListName and WebName attributes we added earlier and use them to find the GUIDs of the list and web in the target enviroment. We should also remove the *Name attributes since SharePoint isn't expecting them:

// Fix List GUID
if (field.Attributes["ListName"] != null)
{
field.Attributes["List"].Value = web.Lists[field.Attributes["ListName"].Value].ID.ToString("B");
field.Attributes.RemoveNamedItem("ListName");
}
// Fix Web GUID
if (field.Attributes["WebName"] != null)
{
using (SPWeb sourceWeb = web.Site.OpenWeb(field.Attributes["WebName"].Value))
{
field.Attributes["WebId"].Value = sourceWeb.ID.ToString("D");
}
field.Attributes.RemoveNamedItem("WebName");
}

I also noticed the SourceID attribute in the schema and that it was (in my case) always the same as the WebId, so just to be safe, I replaced that one too:

// Fix source ID
if (field.Attributes["SourceID"] != null && field.Attributes["SourceID"].Value.StartsWith("{"))
{
field.Attributes["SourceID"].Value = web.ID.ToString("B");
}

You may wish to examine your generated XML for the site columns and make sure that WebId and SourceId are the same in your case too before using this code

Now that the XML has been updated with GUIDs in the new environment we can finally add the column to the web:

web.Fields.AddFieldAsXml(field.OuterXml);

Let's proceed directly to the grand finale: Importing the content types!

As you probably have guessed (or found out the hard way since you're reading this article) There's no documented way of importing content types to webs and preserving the GUIDs. This is most likely a design decision to ensure the uniqueness of content types across all webs of a farm so you may want to examine your options carefully before going down the same dark path that I did. And keep in mind that this code probably doesn't support all content type scenarios. It worked for me, but I didn't need features like workflows, document templates or information management policies. To get a better understanding of the complexities of content types, you can take look at Gary Lapointe's post about copying content types between site collections within the same farm.

Still with me? Cool! Then let's get down to business:

First we need to create an empty SPContentType object. Again, we have to resort to reflection since the SPContentType class doesn't have any public constructors. It's time for another helper method:

private static SPContentType CreateEmptyContentType()
{
ConstructorInfo constructor = (typeof(SPContentType)).GetConstructor(
BindingFlags.NonPublic | BindingFlags.Instance, null, Type.EmptyTypes, null);
SPContentType ctype = (SPContentType)constructor.Invoke(new object[0]);
return ctype;
}

Then we need to call the internal method "Load" to load the XML definition of the content type that we exported earlier:

private static void ReadContentTypeFromXml(SPContentType ctype, XmlTextReader xmlReader)
{
MethodInfo loadMethod = ctype.GetType().GetMethod(
    "Load",
    BindingFlags.NonPublic | BindingFlags.Instance,
    null,
    new Type[] { typeof(XmlReader) },
    null);
loadMethod.Invoke(ctype, new object[] { xmlReader });
}

After that we have to set the scope of the content type and the field reference collection, yet again using reflection:

private static void SetContentTypeScope(SPContentType ctype, SPWeb web)
{
string scope = web.ServerRelativeUrl.TrimStart('/');
MethodInfo setCTScopeMethod = ctype.GetType().GetMethod(
    "SetScope",
    BindingFlags.NonPublic | BindingFlags.Instance,
    null,
    new Type[] { typeof(string) },
    null);
setCTScopeMethod.Invoke(ctype, new object[] { scope });

PropertyInfo fieldLinksScopeProperty = ctype.FieldLinks.GetType().GetProperty(
    "Scope",
    BindingFlags.NonPublic | BindingFlags.Instance,
    null,
    typeof(string),
    Type.EmptyTypes,
    null);
fieldLinksScopeProperty.SetValue(ctype.FieldLinks, scope, new object[0]);

PropertyInfo contentTypeWebProperty = ctype.GetType().GetProperty(
    "Web",
    BindingFlags.NonPublic | BindingFlags.Instance,
    null,
    typeof(SPWeb),
    Type.EmptyTypes,
    null);
contentTypeWebProperty.SetValue(ctype, web, new object[0]);
}

Now all that remains is to call the helper methods and add the content type to the web:SPContentType ctype = CreateEmptyContentType();
XmlTextReader xmlReader = new XmlTextReader(contentType.OuterXml, XmlNodeType.Element, new XmlParserContext(doc.NameTable, nsmgr,"", XmlSpace.Default));
ReadContentTypeFromXml(ctype, xmlReader);
SetContentTypeScope(ctype, web);
web.ContentTypes.Add(ctype);

As soon as I get around to cleaning up my code, I'll post an example application that makes use of the code in this post.

Questions, comments and improvements are of course always welcome!

Posted on SharePoint Blogs

Filtering with SPGridView

Robert Fridén — Mon, 02 Jul 2007 11:18:00 GMT

One of the most exciting new web controls that come with SharePoint 2007 is the SPGridView control. With it, you can present data in a grid view that closely resembles the view that SharePoint uses to display data from lists. You can sort and group rows, add drop-down menus to cells and filter rows using column header drop-down menus.

There is, however, a slight drawback with it; there is almost no official documentation on how to use it. But there is lots of information post on it around the 'net. If you're new to the SPGridView, I suggest you head over to Powlo's blog that has a great introduction of how to use the basic features of the control.

I recently chose to use this control in a scenario where filtering using the UI was required. I had heard about the SPGridView and knew it had the filtering capabilities I needed, but I had a very hard time figuring out how to use it. But after much (unsuccessful) Googling and a lot of trial-and-error on my own, I managed to get it right and thought it would be nice to share this information with others facing the same challenges I did.

The first hurdle I ran into was that filtering does not work if you bind the SPGridView using the DataSource property; you have to use the DataSourceID property to perform the binding. For this example, I wrote a small class that creates a DataTable object with some hardcoded data:

public static class ExampleObjectDataSource
{
public static DataTable GetDataTable()
{
DataTable tblData = new DataTable();
    tblData.Columns.Add("Title");
tblData.Columns.Add("Author");
tblData.Columns.Add("Rating");

    tblData.Rows.Add("Obsession", "Robards, Karen", 2);
    tblData.Rows.Add("Vanished", "Robards, Karen", 3);
    tblData.Rows.Add("Magician: Apprentice", "Feist, Raymong E.", 4);
    tblData.Rows.Add("Magician: Master", "Feist, Raymong E.", 5);
    tblData.Rows.Add("Silverthorn", "Feist, Raymong E.", 4);
    tblData.Rows.Add("Lord Foul's Bane", "Donaldson, Stephen R.", 3);
    tblData.Rows.Add("The Illearth War", "Donaldson, Stephen R.", 4);

    tblData.AcceptChanges();

    return tblData;
}
}

Then simply instantiate an ObjectDataSource object that points to the example data class in the CreateChildControl() method of the web part:

ObjectDataSource odsDataSource = new ObjectDataSource(
"Strand.Demos.FilteredGridExample.ExampleObjectDataSource, Strand.Demos.FilteredGridExample, Culture=neutral, Version=1.0.0.0, PublicKeyToken=9f4da00116c38ec5",
"GetDataTable");
odsDataSource.ID = "ExampleSource";
Controls.Add(odsDataSource);

Of course, we're going to need some columns to display the data. For good measure, I want to implement sorting as well, so let's set the SortExpression properties of the fields too:

sgvGrid = new SPGridView();
sgvGrid.ID = "ExampleGrid";
sgvGrid.AutoGenerateColumns = false;

BoundField col = new BoundField();
col.DataField = "Title";
col.SortExpression = "Title";
col.HeaderText = "Title";
sgvGrid.Columns.Add(col);

col = new BoundField();
col.DataField = "Author";
col.SortExpression = "Author";
col.HeaderText = "Author";
sgvGrid.Columns.Add(col);

col = new BoundField();
col.DataField = "Rating";
col.SortExpression = "Rating";
col.HeaderText = "Rating";
sgvGrid.Columns.Add(col);
sgvGrid.AllowSorting = true;

Next, let's enable the filtering!

sgvGrid.AllowFiltering = true;

Now, we need to tell the SPGridView which columns we want to enable filtering on, and which field each column should use in the filter expression by setting the FilterDataFields property. This is a comma-separated string containing which field each respective column in the grid should filter by. We want to be able to filter by Author or Rating, but not by Title, so leave the first field empty:

sgvGrid.FilterDataFields = ",Author,Rating";

We also need to tell the grid which property to set on the data source control when filtering. In our case, it is the FilterExpression property of the ObjectDataSource:

sgvGrid.FilteredDataSourcePropertyName = "FilterExpression";

The SPGridView control will use string.Format() to generate the string it will set the FilterExpression to, so we must specify the format string it will use. The first parameter is the value to filter on, and the second parameter is the name of the field being filtered.

sgvGrid.FilteredDataSourcePropertyFormat = "{1} LIKE '{0}'";

And lest we forget, let's set the DataSourceID property of the grid and add the grid to the Controls collection:

sgvGrid.DataSourceID = "ExampleSource";
Controls.Add(sgvGrid);

Do the databinding in the Render method:

protected override void Render(HtmlTextWriter writer)
{
sgvGrid.DataBind();
base.Render(writer);
}

Now you'll have filtering implemented and you can compile, deploy and filter the grid to your heart's content!

(Please excuse the Swedish UI!)

If you've come this far and played around with the filtering and sorting for awhile, you've probably noticed that there's something that's not working quite as you'd expect it; If you filter by one column and then sort by another, your filter will disappear! This is of course highly unsatisfactory and needs to be dealt with!

I think my solution to this is a bit on the ugly side, so if anyone out there happens to know the "right" way of doing this, I'd appreciate it if you let me know!

What I did was to first save the FilterExpression in the ViewState in the OnPreRender method:

protected override void OnPreRender(EventArgs e)
{
ViewState["FilterExpression"] = odsDataSource.FilterExpression;

base.OnPreRender(e);
}

Then I inserted code to set the FilterExpression to the previously saved expression in the ViewState. Since I never want the options in the filter menu drop-down to be filtered, I check the query string and then only set the FilterExpression if the current page request is not callback from the drop down menu. This code should be inserted just before adding the odsDataSource object to the Controls collection:

HttpRequest req = HttpContext.Current.Request;
if (req.Form["__CALLBACKID"] == null ||
req.Form["__CALLBACKPARAM"] == null ||
!req.Form["__CALLBACKID"].EndsWith("ExampleGrid"))
{
if (ViewState["FilterExpression"] != null)
odsDataSource.FilterExpression = (string)ViewState["FilterExpression"];
}

And that's it!

Posted on SharePoint Blogs