Corey Roth [MVP] : ECM, SharePoint, SharePoint 2010

A look at content type hubs in SharePoint Online (Office 365)

CoreyRoth — Tue, 21 Feb 2012 02:29:02 GMT

For those of you familiar with SharePoint 2010, the content type hub is nothing new to you. However, in SharePoint Online, the content type hub works a little differently. The first thing to know is that a content type hub has been set up automatically for you. You just have to know where to find it. You can’t get to it from Tenant Administration like you might expect. Instead, you can find the location by going to the Site Settings page of any site collection and then the Content Type Publishing link. You will see a screen like the one below which links directly to the content types of a site collection containing your hub.

From here you will learn that your content type hub is located in a site collection named /sites/contentTypeHub. Clicking on the link from this page will allow you to view the content types in the hub. One issue I have noticed here though is that only the original Office 365 account creator has access to the site collection. Accessing it with another user will get you an access denied error message even if you are a global administrator.

Unfortunately, you cannot fix this yourself from the tenant administration page because this site collection does not show up on the list. This means you need to get the person who created the original Office 365 account to go to this site collection and add you as a site collection administrator. It’s easy to fix but it requires you to involve whomever set up the account to begin with.

Once you get into the content type hub, you can create and publish your desired content types just like you would in SharePoint 2010. When you publish a content type, you should see it in the other site collections within a few minutes.

Working with the content type hub is easy. Try it out with your account today. These examples were demonstrated with an E3 account.

A look at the list editor in Visual Studio 11

CoreyRoth — Fri, 10 Feb 2012 01:28:10 GMT

I’ve written a number of posts in the last couple of weeks about the new SharePoint features in the Visual Studio 11 developer preview. These posts include publishing to SharePoint Online, Visual Web Parts, Silverlight Web Part, and the Content Type Editor. I’ll wrap up this series with a look at the new list editor. The list editor looks fairly similar to the content type editor actually. You start by choosing the List SharePoint Project Item from the New Item menu.

Selecting the List SPI will take you to the next screen where you have the choice of creating a new list which is based off of an existing list (i.e. tasks or document library) or to create a new instance of an existing list type.

Once it is complete, you will see the list editor where you can edit site columns and content types. The site column editor works very similar to the one used for new content types.

The only difference in this interface is that you can actually create new list columns here. If you click the Content Types button at the bottom, you will see a window allowing you to select content types from those available on the server as well as in your current project.

After you have set your content type, the site columns of the content type will automatically be added to the site column list. From here, you can click on the Views tab to edit the existing views (or add a new one). You’ll notice that all views are visible (including ones you normally wouldn’t touch). Be careful with what you do here. You can customize the columns in each view. Unfortunately, the user interface doesn’t give you any control over how things look, row groupings, or sort order though.

Finally, the Common Properties tab lets you set the title, URL, description, whether the list is hidden or not and on the Quick Launch bar.

Once you have finished your list, you can deploy it to a local SharePoint server or publish it to SharePoint Online. When you visit the site, an instance of the list will be there ready to go.

That’s just a quick look at what you can do with Visual Studio 11 Developer Preview. If you haven’t checked it out yet be sure and visit the developer center on MSDN.

A quick look at the content type editor in Visual Studio 11

CoreyRoth — Mon, 06 Feb 2012 16:52:10 GMT

Visual Studio 11 introduces a new content type editor that you might find useful when building your next content type. It starts with a SharePoint Project Item that you can pick from the New Item menu.

From this screen, give your new content type a name and then you’ll be presented with this next screen allowing you to pick a content type to inherit from. This pulls a list of every content type currently on the site collection that you have your Visual Studio project associated with.

Pick the content type you want to inherit from and you will then see the new content type editor.

From here you can begin adding exiting site columns to your new content type.

Selecting one will bring over the type automatically. Unfortunately the only option you get here is whether the column is required or not. However, you can click on the elements.xml file in the solution explorer to edit the XML directly. I’ve tested and it will preserve any additional attributes you add to your site column references there.

You might be wondering what about site columns that have not been created yet. The editor is actually smart and knows to look at any site columns defined in the same project as well. For example, I created this new site column below.

Unfortunately, creating site columns still requires XML, but Visual Studio at least gets you started. After you save your new site column, you will find the site column in the list.

You can also set some of the common properties such as the group and description of the content type itself by clicking on Common Properties.

What about inheriting from your own content type in the same project? That actually works as well. However, you will have to look for it at the top of the content type list.

That’s a quick look at what Visual Studio offers for content type editing. I think the SharePoint Designer still has a few more features, but the main difference is what you create here can actually be deployed elsewhere. This will work with SharePoint Online as well. Just use the new publish feature I have talked about earlier.

For more information on Visual Studio 11, go to the Developer Preview site.

How to: search the contents of a document set

CoreyRoth — Wed, 09 Nov 2011 22:03:44 GMT

I saw this question in the forums the other day, so I decided to see if it is possible to use SharePoint search to query just the contents of a document set. It turns out that you can and it is quite easy. Consider the following document set. It has a number of contracts in it.

I want to be able to search the content of the document set. Document Sets are really just fancy folders. You can tell this by examining the URL when you are viewing one. Since it is just a folder, I realized that we can make use of the Site keyword that I have talked about before. Simply provide the URL and you will return all of the results of the document set. Here is an example. I can return the entire contents of the document set like in this example.

site:"http://sp2010/RM Test/Work Package 1/"

In the above example, my server is sp2010, the document library is RM Test and the document set is named Work Package 1. Here are the search results. Note, that it returns the documents in the document set as well as the welcome page.

Of course we can combine this with other terms. For example if I want to search for documents in this set that involve the state of Texas, I would issue the following query.

site:"http://sp2010/RM Test/Work Package 1/" Texas

As you can see querying the document set is easy. Now your users might not be able to create a query like that very easily, but as a developer it gives you something to work with. To search within large document sets, you could add a custom SearchBoxEx web part to the welcome page. The reason you would have to customize it is because you need the site keyword to pass in the URL of the document set. This could be done by inheriting from SearchBoxEx and by adding some simple code to get the current URL. I’ll look at building this web part in the future when I have more time. In the meantime, if you build one, drop me a line and tell me about it.

Slides from my talks at SPTechCon Boston 2011

CoreyRoth — Mon, 20 Jun 2011 21:54:46 GMT

This post is long overdue, but better late than never. I had a great time at SPTechCon 2011 in Boston. I had the chance to meet a lot of people in person for the first time that I had only previously known through twitter. I gave two talks this year. The first being my Instant ECM talk showing you how to leverage out-of-the-box SharePoint ECM features. My second talk was an advanced developer talk discussing how to build Business Data Connectivity models and custom connectors. My slides can be found on SlideShare. It was definitely great to get out to the east coast and see how people were using SharePoint.

Instant ECM with SharePoint 2010 - SPTechCon Boston 2011 Slides

Advanced BCS: Business Data Connectivity Models and Custom Connectors – SPTechCon 2011 Slides

Follow me on twitter @coreyroth.

How to: Deploy Metadata Navigation without using code

CoreyRoth — Wed, 09 Feb 2011 22:37:29 GMT

As someone who focuses mostly on ECM and Search, I am a huge fan of the new Metadata Navigation feature on document libraries in SharePoint 2010. It provides a great alternative to folders when it comes to navigating your document libraries. A list administrator can configure Metadata navigation on the document library settings page. However, I prefer to make changes using CAML or code so that I can deploy them easily to other environments. Usually, my first choice is with CAML, so I did some digging today and I discovered the trick to deploying your Metadata navigation settings using a SharePoint feature.

When I first started investigating this, I assumed it might be some new element or attribute inside the schema.xml file of the list. It turns out my assumption was incorrect. We actually set this by assigning some XML to the client_MOSS_MetadataNavigationSettings property on the root folder of the list. We can assign this value using code, but you know I prefer to use CAML. We can use the PropertyBag element to make this happen. Before we look at the PropertyBag element itself though, let’s look at the underlying XML. Let’s take my list here with three items selected for Metadata Navigation: a site column named DocumentType, the Content Type of the documents in the library, and the Folders in the library itself. Here is what the XML will look like.

<MetadataNavigationSettings SchemaVersion="1" IsEnabled="True" AutoIndex="True">
  <NavigationHierarchies>
    <FolderHierarchy HideFoldersNode="False" />
    <MetadataField FieldID="3c6f8f63-0616-437c-80eb-cf7cba0d88cc" FieldType="Choice" CachedName="DocumentType" CachedDisplayName="DocumentType" />
    <MetadataField FieldID="03e45e84-1992-4d42-9116-26f756012634" FieldType="ContentTypeId" CachedName="ContentTypeId" CachedDisplayName="Content Type" />
  </NavigationHierarchies>
  <ManagedIndices>
    <ManagedIndex IndexID="3c6f8f63-0616-437c-80eb-cf7cba0d88cc" IndexFieldName="DocumentType" IndexFieldID="3c6f8f63-0616-437c-80eb-cf7cba0d88cc" />
  </ManagedIndices>
</MetadataNavigationSettings>

The first line seems to always be the same. It enables the Metadata Navigation and it will take care of automatically adding new index columns when AutoIndex is set to true. The NavigationHierarchies section actually defines which fields will be used for Metadata navigation. If you want to navigate by folders, add a FolderHierarchy element and set HideFoldersNode to false. If you set it to true, folder navigation will not be present. The MetadataField element defines which fields to use for navigation. You need the GUID for each site column to include. You can get this from your list’s schema.xml file. You then need to specify the FieldType. Remember that it only supports Single-value Choice (Choice), Managed Metadata (TaxonomyFieldType) , and Content Type (ContentTypeId) field types. You then need to specify the field name in the CachedName field and then you can customize the display name as you see fit with CachedDisplayName. The last thing to note here is that you have to create a Managed Index for any choice fields you add. This is why you see a ManagedIndex element with the DocumentType field. Set the IndexId and IndexFieldId attributes equal to the Id of the field.

At this point, we are ready to assign this XML to the the client_MOSS_MetadataNavigationSettings property. We need to encode the above XML, because it is being stored inside an attribute of another XML document. Here is what your elements.xml file would look like.

<?xml version="1.0" encoding="utf-8"?>
<Elements xmlns="http://schemas.microsoft.com/sharepoint/">
  <PropertyBag Url="Shared Documents" ParentType="Folder" RootWebOnly="FALSE" xmlns="http://schemas.microsoft.com/sharepoint/">
    <Property Name="client_MOSS_MetadataNavigationSettings" Value="&lt;MetadataNavigationSettings SchemaVersion=&quot;1&quot; IsEnabled=&quot;True&quot; AutoIndex=&quot;True&quot;&gt;&lt;NavigationHierarchies&gt;&lt;FolderHierarchy HideFoldersNode=&quot;True&quot; /&gt;&lt;MetadataField FieldID=&quot;3c6f8f63-0616-437c-80eb-cf7cba0d88cc&quot; FieldType=&quot;Choice&quot; CachedName=&quot;DocumentType&quot; CachedDisplayName=&quot;DocumentType&quot; /&gt; &lt;MetadataField FieldID=&quot;03e45e84-1992-4d42-9116-26f756012634&quot; FieldType=&quot;ContentTypeId&quot; CachedName=&quot;ContentTypeId&quot; CachedDisplayName=&quot;Content Type&quot; /&gt; &lt;/NavigationHierarchies&gt;&lt;ManagedIndices&gt;&lt;ManagedIndex IndexID=&quot;3c6f8f63-0616-437c-80eb-cf7cba0d88cc&quot; IndexFieldName=&quot;DocumentType&quot; IndexFieldID=&quot;3c6f8f63-0616-437c-80eb-cf7cba0d88cc&quot; /&gt;&lt;ManagedIndex IndexID=&quot;d31655d1-1d5b-4511-95a1-7a09e9b75bf2&quot; IndexFieldName=&quot;Editor&quot; IndexFieldID=&quot;d31655d1-1d5b-4511-95a1-7a09e9b75bf2&quot; /&gt;&lt;/ManagedIndices&gt;&lt;/MetadataNavigationSettings&gt;" Type="string" />
  </PropertyBag>
</Elements>

It’s kind of hard to read the contents of the Property element, but it is just the encoded version of the XML above. As for the PropertyBag element, you just specify the relative Url to the document library on your site. In this case, it’s Shared Documents. Always set ParentType to Folder and RootWebOnly to false. At this point, you can activate this feature after you have deployed your document library and it will enable the Metadata navigation. Here is what the Metadata Navigation settings page looks like.

Here is what my document library looks like with the navigation enabled.

It’s pretty easy to set this up as you can see. Keep in mind that if you set this value, it will overwrite any values previously stored. This includes any Key Filters or Indexes that might already be present on the list.

Speaking of Key Filters, we can add them to the document library using the client_MOSS_MetadataNavigationSettings as well. Let’s look at some more XML. In this case, I am adding key filters for DocumentType, All Tags, and Modified By (editor).

<MetadataNavigationSettings SchemaVersion="1" IsEnabled="True" AutoIndex="True">
  <KeyFilters>
    <MetadataField FieldID="3c6f8f63-0616-437c-80eb-cf7cba0d88cc" FieldType="Choice" CachedName="DocumentType" CachedDisplayName="DocumentType" />
    <MetadataField FieldID="23f27201-bee3-471e-b2e7-b64fd8b7ca38" FieldType="TaxonomyFieldTypeMulti" CachedName="TaxKeyword" CachedDisplayName="All Tags" />
    <MetadataField FieldID="d31655d1-1d5b-4511-95a1-7a09e9b75bf2" FieldType="User" CachedName="Editor" CachedDisplayName="Modified By" />
  </KeyFilters>
  <ManagedIndices>
    <ManagedIndex IndexID="d31655d1-1d5b-4511-95a1-7a09e9b75bf2" IndexFieldName="Editor" IndexFieldID="d31655d1-1d5b-4511-95a1-7a09e9b75bf2" />
  </ManagedIndices>
</MetadataNavigationSettings>

The elements are pretty similar to that of the NavigationHierarchies element. You add one MetadataField element for each field you want with the same attributes as before. However, a few more fields types are supported such as Person or Group (User). It also recognizes Enterprise Keywords through the use of the All Tags (TaxonomyFieldMulti) filter. You can also do Date and Time fields as well as Number fields too. I also added the ManagedIndex field for Editor (the Modified By filter). You can probably leave the indexes out since AutoIndex is true, but if you run into issues, you can add them manually as you see above. You can deploy KeyFilters and NavigationHierarchies elements at the same time. You’ll need to encode the XML again just as you did before. When you activate the feature, you’ll have Key Filters enabled on your document library.

Using the PropertyBag element, you can easily add metadata navigation to your document libraries. This is a great alternative to defining these settings using code.

How to: Provision a Document Set using CAML

CoreyRoth — Mon, 29 Nov 2010 20:53:28 GMT

When it comes to deploying SharePoint artifacts, I pretty much always insist on doing as much as possible using a feature and CAML as opposed to using the UI or writing code. CAML is very possible and most people don’t realize how much you can do with it. The XML scares a lot of people but there are a lot of techniques you can use now in SharePoint 2010 to avoid writing a lot of this manually. This article assumes you have some familiarity in deploying content types and site columns using a feature. If you need more information on this, feel free to ask and I’ll post more on it.

As you probably know a Document Set is simply a content type which contains other content types. For today’s example, I’m going to deploy a Document Set called Work Order. It will contain two child content types: Contract and Invoice. Let’s look at these child content types real quick. Both inherit from Document and I only specifically list my custom site columns in it.

Here is what Contract looks like:

<?xml version="1.0" encoding="utf-8"?>
<Elements xmlns="http://schemas.microsoft.com/sharepoint/">
  <ContentType ID="0x0101000F9EF6A4CF6E7046A227BC48222671DC" Name="Contract" Group="Custom Content Types" Overwrite="TRUE" xmlns="http://schemas.microsoft.com/sharepoint/">
    <Folder TargetName="_cts/Contract" />
    <FieldRefs>
     
      <FieldRef ID="{6d392ce3-12e0-49f7-ba79-04f2b2e67269}" Name="Contract_x0020_Number" />
      <FieldRef ID="{f7b6fc7c-eb22-43dd-89a5-799874d7a5d7}" Name="Effective_x0020_Date" />
    </FieldRefs>
    <XmlDocuments>
      <XmlDocument NamespaceURI="http://schemas.microsoft.com/sharepoint/v3/contenttype/forms">
        <FormTemplates xmlns="http://schemas.microsoft.com/sharepoint/v3/contenttype/forms">
          <Display>DocumentLibraryForm</Display>
          <Edit>DocumentLibraryForm</Edit>
          <New>DocumentLibraryForm</New>
        </FormTemplates>
      </XmlDocument>
    </XmlDocuments>
  </ContentType>
</Elements>

My Invoice content type looks quite similar. Note that the Contract Number field is shared between the two content types.

<?xml version="1.0" encoding="utf-8"?>
<Elements xmlns="http://schemas.microsoft.com/sharepoint/">
  <ContentType ID="0x0101006754EF61193E3942B6851FBE641DD21E" Name="Invoice" Group="Custom Content Types" Overwrite="TRUE" xmlns="http://schemas.microsoft.com/sharepoint/">
    <Folder TargetName="_cts/Invoice" />
    <FieldRefs>
      <FieldRef ID="{6d392ce3-12e0-49f7-ba79-04f2b2e67269}" Name="Contract_x0020_Number" />
      <FieldRef ID="{1dfcbcef-d1e1-42a1-bd59-a2079cc7ca36}" Name="Amount" />
    </FieldRefs>
    <XmlDocuments>
      <XmlDocument NamespaceURI="http://schemas.microsoft.com/sharepoint/v3/contenttype/forms">
        <FormTemplates xmlns="http://schemas.microsoft.com/sharepoint/v3/contenttype/forms">
          <Display>DocumentLibraryForm</Display>
          <Edit>DocumentLibraryForm</Edit>
          <New>DocumentLibraryForm</New>
        </FormTemplates>
      </XmlDocument>
    </XmlDocuments>
  </ContentType>
</Elements>

Now how do we deploy the Document Set? It’s actually not that complicated. We define it just like a regular content type that inherits from Content Type Id 0x0120D520. Here is what the first line looks like in the elements.xml for my Document Set. As you can see, I started with that Content Type Id and appended 00, plus my own GUID (minus dashes and brackets).

<ContentType ID="0x0120D5200032EBDCE82398324CAD4E4E21C3233AA7" Name="Work Order" Group="Custom Content Types" Overwrite="TRUE" ProgId="SharePoint.DocumentSet" PushDownChangedResourceFilesOnly="TRUE" xmlns="http://schemas.microsoft.com/sharepoint/">

In the next section, I reference my custom site columns, Contract Number. I included all of the other FieldRef elements that are inherited but I expect you can leave them out.

<FieldRefs>
  <FieldRef ID="{c042a256-787d-4a6f-8a8a-cf6ab767f12d}" Name="ContentType" />
  <FieldRef ID="{b824e17e-a1b3-426e-aecf-f0184d900485}" Name="ItemChildCount" />
  <FieldRef ID="{960ff01f-2b6d-4f1b-9c3f-e19ad8927341}" Name="FolderChildCount" />
  <FieldRef ID="{fa564e0f-0c70-4ab9-b863-0177e6ddd247}" Name="Title" Required="FALSE" Hidden="TRUE" />
  <FieldRef ID="{8553196d-ec8d-4564-9861-3dbe931050c8}" Name="FileLeafRef" Required="TRUE" Hidden="FALSE" />
  <FieldRef ID="{cbb92da4-fd46-4c7d-af6c-3128c2a5576e}" Name="Description" ShowInNewForm="TRUE" ShowInEditForm="TRUE" />
  <FieldRef ID="{6d392ce3-12e0-49f7-ba79-04f2b2e67269}" Name="Contract_x0020_Number" />
</FieldRefs>

The rest of the magic behind Document Sets exists in the XmlDocuments section of the content type. I won’t describe all of them but I will include the ones that are of interest. The most important section describes which content types are in the Document Set. You need to include one AllowedContentType element for each content type included. In this case, I have the Content Type Ids for Document, Contract, and Invoice.

<XmlDocument NamespaceURI="http://schemas.microsoft.com/office/documentsets/allowedcontenttypes">
  <act:AllowedContentTypes xmlns:act="http://schemas.microsoft.com/office/documentsets/allowedcontenttypes" LastModified="11/29/2010 18:57:35">
    <AllowedContentType id="0x0101" />
    <AllowedContentType id="0x0101000F9EF6A4CF6E7046A227BC48222671DC" />
    <AllowedContentType id="0x0101006754EF61193E3942B6851FBE641DD21E" />
  </act:AllowedContentTypes>
</XmlDocument>

The SharedField element specifies which fields are shared between content types. The value of this site column set at the Document Set level will be written into the child content types automatically.

<XmlDocument NamespaceURI="http://schemas.microsoft.com/office/documentsets/sharedfields">
  <sf:SharedFields xmlns:sf="http://schemas.microsoft.com/office/documentsets/sharedfields" LastModified="11/29/2010 18:58:08">
    <SharedField id="6d392ce3-12e0-49f7-ba79-04f2b2e67269" />
  </sf:SharedFields>
</XmlDocument>

The WelcomePageField element controls which site columns show up on the welcome page of the content type. In this case I want the Contract Number displayed so I include that site column’s Id.

<XmlDocument NamespaceURI="http://schemas.microsoft.com/office/documentsets/welcomepagefields">
  <wpf:WelcomePageFields xmlns:wpf="http://schemas.microsoft.com/office/documentsets/welcomepagefields" LastModified="11/29/2010 18:58:08">
    <WelcomePageField id="6d392ce3-12e0-49f7-ba79-04f2b2e67269" />
  </wpf:WelcomePageFields>
</XmlDocument>

Document Sets also give you the ability to create default documents for each content type in the set. The DefaultDocument element is how you do this by specifying a filename and a Content Type Id. I’ll talk about how you actually get the files deployed in the right place here in a little bit.

<XmlDocument NamespaceURI="http://schemas.microsoft.com/office/documentsets/defaultdocuments">
  <dd:DefaultDocuments xmlns:dd="http://schemas.microsoft.com/office/documentsets/defaultdocuments" LastModified="11/29/2010 17:06:58" AddSetName="True">
    <DefaultDocument name="Contract Template.docx" idContentType="0x0101000F9EF6A4CF6E7046A227BC48222671DC" />
    <DefaultDocument name="Invoice Template.xlsx" idContentType="0x0101006754EF61193E3942B6851FBE641DD21E" />
  </dd:DefaultDocuments>
</XmlDocument>

Here is what the whole elements.xml file looks like for my document set. I omitted details on a few of the XmlDocument elements but they seem to always have the same values.

<?xml version="1.0" encoding="utf-8"?>
<Elements xmlns="http://schemas.microsoft.com/sharepoint/">
  <ContentType ID="0x0120D5200032EBDCE82398324CAD4E4E21C3233AA7" Name="Work Order" Group="Custom Content Types" Overwrite="TRUE" ProgId="SharePoint.DocumentSet" PushDownChangedResourceFilesOnly="TRUE" xmlns="http://schemas.microsoft.com/sharepoint/">
    <Folder TargetName="_cts/Work Order" />
    <FieldRefs>
      <FieldRef ID="{c042a256-787d-4a6f-8a8a-cf6ab767f12d}" Name="ContentType" />
      <FieldRef ID="{b824e17e-a1b3-426e-aecf-f0184d900485}" Name="ItemChildCount" />
      <FieldRef ID="{960ff01f-2b6d-4f1b-9c3f-e19ad8927341}" Name="FolderChildCount" />
      <FieldRef ID="{fa564e0f-0c70-4ab9-b863-0177e6ddd247}" Name="Title" Required="FALSE" Hidden="TRUE" />
      <FieldRef ID="{8553196d-ec8d-4564-9861-3dbe931050c8}" Name="FileLeafRef" Required="TRUE" Hidden="FALSE" />
      <FieldRef ID="{cbb92da4-fd46-4c7d-af6c-3128c2a5576e}" Name="Description" ShowInNewForm="TRUE" ShowInEditForm="TRUE" />
      <FieldRef ID="{6d392ce3-12e0-49f7-ba79-04f2b2e67269}" Name="Contract_x0020_Number" />
    </FieldRefs>
    <XmlDocuments>
      <XmlDocument NamespaceURI="http://schemas.microsoft.com/office/documentsets/defaultdocuments">
        <dd:DefaultDocuments xmlns:dd="http://schemas.microsoft.com/office/documentsets/defaultdocuments" LastModified="11/29/2010 17:06:58" AddSetName="True">
          <DefaultDocument name="Contract Template.docx" idContentType="0x0101000F9EF6A4CF6E7046A227BC48222671DC" />
          <DefaultDocument name="Invoice Template.xlsx" idContentType="0x0101006754EF61193E3942B6851FBE641DD21E" />
        </dd:DefaultDocuments>
      </XmlDocument>
      <XmlDocument NamespaceURI="http://schemas.microsoft.com/office/documentsets/welcomepageview">
        <WelcomePageView xmlns="http://schemas.microsoft.com/office/documentsets/welcomepageview" LastModified="1/1/1 0:00:01 AM" />
      </XmlDocument>
      <XmlDocument NamespaceURI="http://schemas.microsoft.com/office/documentsets/allowedcontenttypes">
        <act:AllowedContentTypes xmlns:act="http://schemas.microsoft.com/office/documentsets/allowedcontenttypes" LastModified="11/29/2010 18:57:35">
          <AllowedContentType id="0x0101" />
          <AllowedContentType id="0x0101000F9EF6A4CF6E7046A227BC48222671DC" />
          <AllowedContentType id="0x0101006754EF61193E3942B6851FBE641DD21E" />
        </act:AllowedContentTypes>
      </XmlDocument>
      <XmlDocument NamespaceURI="http://schemas.microsoft.com/office/documentsets/sharedfields">
        <sf:SharedFields xmlns:sf="http://schemas.microsoft.com/office/documentsets/sharedfields" LastModified="11/29/2010 18:58:08">
          <SharedField id="6d392ce3-12e0-49f7-ba79-04f2b2e67269" />
        </sf:SharedFields>
      </XmlDocument>
      <XmlDocument NamespaceURI="http://schemas.microsoft.com/office/documentsets/welcomepagefields">
        <wpf:WelcomePageFields xmlns:wpf="http://schemas.microsoft.com/office/documentsets/welcomepagefields" LastModified="11/29/2010 18:58:08">
          <WelcomePageField id="6d392ce3-12e0-49f7-ba79-04f2b2e67269" />
        </wpf:WelcomePageFields>
      </XmlDocument>
      <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>DocSetDisplayForm</New>
        </FormTemplates>
      </XmlDocument>
      <XmlDocument NamespaceURI="http://schemas.microsoft.com/sharepoint/v3/contenttype/forms/url">
        <FormUrls xmlns="http://schemas.microsoft.com/sharepoint/v3/contenttype/forms/url">
          <New>_layouts/NewDocSet.aspx</New>
        </FormUrls>
      </XmlDocument>
    </XmlDocuments>
  </ContentType>
</Elements>

Note the path specified in the folder element as this is important. I mentioned that there were extra steps involved in deploying the default documents. For this we need a module element. We also need this module element to deploy the actual page that is displayed when you view the document set. Start by creating a new module in Visual Studio 2010. In the module, create a folder called _cts. Then create a subfolder under that which is unique to your content type. In this case, I named it Work Order to match the name of my content type. Now we need to get a copy of the page that displays when you view the document set. By default, this file is called docsethomepage.aspx. You can find it in 14\FEATURES\DocumentSet. You can also get it by exporting a site template that has a document set. You import the .wsp file in Visual Studio and then look for the corresponding cts module entry. The last step is a bit more involved, but it is how I determined which web parts to include in the module element. Drag this page into your module folder along with the default documents you want for your content type (i.e.: Contact Template.docx and Invoice Template.xlsx).

Here is what my completed module elements.xml looks like.

<?xml version="1.0" encoding="utf-8"?>
<Elements xmlns="http://schemas.microsoft.com/sharepoint/">
  <Module Name="WorkOrderCts">
    <File Path="WorkOrderCts\_cts\Work Order\docsethomepage.aspx" Url="_cts/Work Order/docsethomepage.aspx">
      <AllUsersWebPart WebPartOrder="0" WebPartZoneID="WebPartZone_TopLeft" ID="g_737f2b01_0a4b_4cd9_9c5e_658e2ad65920">
        <![CDATA[<WebPart xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns="http://schemas.microsoft.com/WebPart/v2">
  <Title>Image</Title>
  <FrameType>Default</FrameType>
  <Description>Use to display pictures and photos.</Description>
  <IsIncluded>true</IsIncluded>
  <ZoneID>WebPartZone_TopLeft</ZoneID>
  <PartOrder>0</PartOrder>
  <FrameState>Normal</FrameState>
  <AllowRemove>true</AllowRemove>
  <AllowZoneChange>true</AllowZoneChange>
  <AllowMinimize>true</AllowMinimize>
  <AllowConnect>true</AllowConnect>
  <AllowEdit>true</AllowEdit>
  <AllowHide>true</AllowHide>
  <IsVisible>true</IsVisible>
  <HelpMode>Modeless</HelpMode>
  <Dir>Default</Dir>
  <MissingAssembly>Cannot import this Web Part.</MissingAssembly>
  <Assembly>Microsoft.SharePoint, Version=14.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c</Assembly>
  <TypeName>Microsoft.SharePoint.WebPartPages.ImageWebPart</TypeName>
  <ImageLink xmlns="http://schemas.microsoft.com/WebPart/v2/Image">/_layouts/images/docset_welcomepage_big.png</ImageLink>
</WebPart>]]>
      </AllUsersWebPart>
      <AllUsersWebPart WebPartOrder="0" WebPartZoneID="WebPartZone_CenterMain" ID="g_8882074f_409f_4ce4_8fb9_7e4ce9aa1d93">
        <![CDATA[<WebPart xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns="http://schemas.microsoft.com/WebPart/v2">
  <Title>Document Set Contents</Title>
  <FrameType>Default</FrameType>
  <Description>Displays the contents of the Document Set.</Description>
  <IsIncluded>true</IsIncluded>
  <ZoneID>WebPartZone_CenterMain</ZoneID>
  <PartOrder>0</PartOrder>
  <FrameState>Normal</FrameState>
  <AllowRemove>true</AllowRemove>
  <AllowZoneChange>true</AllowZoneChange>
  <AllowMinimize>true</AllowMinimize>
  <AllowConnect>true</AllowConnect>
  <AllowEdit>true</AllowEdit>
  <AllowHide>true</AllowHide>
  <IsVisible>true</IsVisible>
  <HelpMode>Modeless</HelpMode>
  <Dir>Default</Dir>
  <MissingAssembly>Cannot import this Web Part.</MissingAssembly>
  <PartImageLarge>/_layouts/images/msimagel.gif</PartImageLarge>
  <Assembly>Microsoft.Office.DocumentManagement, Version=14.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c</Assembly>
  <TypeName>Microsoft.Office.Server.WebControls.DocumentSetContentsWebPart</TypeName>
</WebPart>]]>
      </AllUsersWebPart>
      <AllUsersWebPart WebPartOrder="0" WebPartZoneID="WebPartZone_Top" ID="g_357da23e_61eb_473c_8eac_5609fc574329">
        <![CDATA[<WebPart xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns="http://schemas.microsoft.com/WebPart/v2">
  <Title>Document Set Properties</Title>
  <FrameType>Default</FrameType>
  <Description>Displays the properties of the Document Set.</Description>
  <IsIncluded>true</IsIncluded>
  <ZoneID>WebPartZone_Top</ZoneID>
  <PartOrder>0</PartOrder>
  <FrameState>Normal</FrameState>
  <AllowRemove>true</AllowRemove>
  <AllowZoneChange>true</AllowZoneChange>
  <AllowMinimize>true</AllowMinimize>
  <AllowConnect>true</AllowConnect>
  <AllowEdit>true</AllowEdit>
  <AllowHide>true</AllowHide>
  <IsVisible>true</IsVisible>
  <HelpMode>Modeless</HelpMode>
  <Dir>Default</Dir>
  <MissingAssembly>Cannot import this Web Part.</MissingAssembly>
  <PartImageLarge>/_layouts/images/msimagel.gif</PartImageLarge>
  <Assembly>Microsoft.Office.DocumentManagement, Version=14.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c</Assembly>
  <TypeName>Microsoft.Office.Server.WebControls.DocumentSetPropertiesWebPart</TypeName>
</WebPart>]]>
      </AllUsersWebPart>
    </File>
    <File Path="WorkOrderCts\_cts\Work Order\Invoice Template.xlsx" Url="_cts/Work Order/Invoice Template.xlsx" />
    <File Path="WorkOrderCts\_cts\Work Order\Contract Template.docx" Url="_cts/Work Order/Contract Template.docx" />
  </Module>
</Elements>

The three web parts included in the docsethomepage.aspx file element display the details of the documents set when a user views the page. If you want to customize this page, you could add web parts here or customize docsethomepage.aspx itself. In this section make sure the Url element of each File element contains the path specified in the Folder element of the Document Set content type (_cts/Work Order in this case). With all this put together, your Visual Studio project will look something like this.

At this point, you can deploy this solution. Make sure the destination site collection has the Document Sets feature activated otherwise things won’t work right. If all goes well, you will have a working Document Set with all of the settings you specified. You can go to the Content Types page, edit your content type and look at the Document Set Settings link to verify that it was create successfully.

If everything looks good with your content type, add it to a document library and try creating a new Document Set. If it works right, you will have a new instance of your Document Set and you will see a page like the one below.

As you can see, it successfully created the default documents and it is displaying my Contract Number field.

Ok, this process may seem a bit involved at this point but it’s really not bad. You can always create this stuff in the UI and then export as site template. Once you export a site template, you can import the pieces you want into a new project. I’ll write up a post on this topic in the future as it is a great way to learn how SharePoint 2010 works behind the scenes.

Spice up your ECM with Ratings in SharePoint 2010!

CoreyRoth — Mon, 22 Nov 2010 16:23:34 GMT

At Tulsa TechFest, I gave a talk about the various new ECM features available out of the box in SharePoint 2010. One feature of particular interest to the crowd was average ratings. I had lots of questions on it so I thought it was worth a blog post. Instead of describing it first, let’s start with a picture.

As you can see in the above picture, ratings are a new field available which gives users the ability to rate each document using stars just like they might do in iTunes or any other application. Behind the scenes, it takes the ratings of each user and a timer job comes along periodically and calculates the average rating. This allows users to quickly determine which documents are the most popular when viewing a document library. You can also sort on this field as well. It’s easy to add to both your document libraries and content types.

In reality, Ratings are nothing more than a site column, but SharePoint 2010 makes it really easy to add them to an existing document library. Just click on Library Settings in the ribbon and then Ratings settings.

One you do that, two new site columns are added to your document library, Rating (0-5) and Number of Ratings. The Rating (0-5) site column, named AverageRating internally, is the column users interact with. Users can’t edit the Number of Ratings column, named RatingCount internally. The timer job just uses it to help calculate the average.

At this point, your users can start rating documents. It’s that simple. When you view the properties on a document, you will see the average rating and the number of ratings as well.

In reality, you can actually just add the above two site columns to any list or content type and have ratings work. I have actually started including these in my base content type on most ECM deployments. This is a content type that I use in lieu of the Document content type which has additional site columns. All other content types I create will inherit from this one. It adds great functionality to every content type that inherits from it. If some people don’t like the ratings on their documents, they can always just remove it from the view on his or her document library.

To add the columns to a content type, just click the Add from existing site columns link on your content type page. You will find the two columns listed in the Ratings Group. You will want to add both of them to your content type.

When you add one of these columns, you will get a warning stating that some earlier versions of Office cannot use these fields. If you are using Office 2007 or earlier, you may want to test this out some to see if it will be an issue in your organization.

Once you click OK, your content type is ready for use. Now, I would be a bad blogger if I didn’t show you how to add these fields using CAML. If you want to add these two fields to a content type, just add the following elements to the FieldRefs element.

<FieldRef ID="{5a14d1ab-1513-48c7-97b3-657a5ba6c742}" Name="AverageRating" />
<FieldRef ID="{b1996002-9167-45e5-a4df-b2c41c6723c7}" Name="RatingCount" />

Since these fields are included out-of-the-box, I believe those GUIDs should always be the same. If I’m wrong, someone let me know. You can also add these fields to document libraries as well. Just add the following Field elements to the Fields element in your schema.xml.

<Field ID="{5a14d1ab-1513-48c7-97b3-657a5ba6c742}" Name="AverageRating" StaticName="AverageRating" DisplayName="Rating (0-5)" Description="Average value of all the ratings that have been submitted" Group="Ratings" Type="AverageRating" Decimals="2" Min="0" Max="5" ShowInEditForm="TRUE" ShowInDisplayForm="TRUE" ShowInNewForm="FALSE" SourceID="http://schemas.microsoft.com/sharepoint/v3" RowOrdinal="0" />
<Field ID="{b1996002-9167-45e5-a4df-b2c41c6723c7}" Name="RatingCount" StaticName="RatingCount" DisplayName="Number of Ratings" Description="Number of ratings submitted" Group="Ratings" Type="RatingCount" Min="0" Decimals="0" ShowInEditForm="FALSE" ShowInDisplayForm="TRUE" ShowInNewForm="FALSE" SourceID="http://schemas.microsoft.com/sharepoint/v3" RowOrdinal="0" />

Try out document ratings today. They provide a lot of functionality and are quite easy to implement.

Slides from my talk at Tulsa TechFest 2010

CoreyRoth — Sun, 14 Nov 2010 23:01:46 GMT

It’s hard to believe this is my fourth Tulsa TechFest. It seemed like we just had the last one. As always I had a good time. I’m impressed that @davidlwalker was able to pull off such an event when he barely even lives here. For a city the size of Tulsa, this event pulls in an impressive number of people. The event easily has 600+ people each year. My goal this year is to raise awareness of the event and get some more out-of-town speakers from the SharePoint community to attend. I will be contacting all of you. :) @mrackley made the trip over and gave a talk to a full room. It was good to see him and glad he was able to make it here despite his 90+ hour work weeks.

I got to do two topics this year. The first topic was my SharePoint 2010 Development for ASP.NET Developers talk. I was impressed with the turnout to this early morning talk. It clearly indicated to me that SharePoint 2010 is a hot topic right now in Oklahoma. My next talk was about out-of-the-box ECM features in SharePoint 2010. It consisted of a series of demonstrations covering the various ECM features you can turn on in SharePoint 2010. It was good to see everyone again and I met a lot of new people. If you have any questions about the talk, feel free to contact me.

I almost forgot to post the links to the slides out at SlideShare.

Instant ECM in SharePoint 2010
SharePoint 2010 Development for ASP.NET Developers

How to: Set Default Column Values on a folder programmatically

CoreyRoth — Mon, 19 Jul 2010 20:51:27 GMT

The reason I write this post today is because my initial searches on the Internet provided me with nothing on the topic. I was hoping to find a reference to the SDK but I didn’t have any luck. What I want to do is set a default column value on an existing folder so that new items in that folder automatically inherit that value. It’s actually pretty easy to do once you know what the class is called in the API. I did some digging and discovered that class is MetadataDefaults. It can be found in Microsoft.Office.DocumentManagement.dll. Note: if you can’t find it in the GAC, this DLL is in the 14/CONFIG/BIN folder and not the 14/ISAPI folder. Add a reference to this DLL in your project. In my case, I am building a console application, but you might put this in an event receiver or workflow.

In my example today, I have simple custom folder and document content types. I have one shared site column called DocumentType. I have a document library which each of these content types registered. In my document library, I have a folder named Test and I want to set its default column values using code. Here is what it looks like. Start by getting a reference to the list in question. This assumes you already have a SPWeb object. In my case I have created it and it is called site.

SPList customDocumentLibrary = site.Lists["CustomDocuments"];

You then pass the SPList object to the MetadataDefaults constructor.

MetadataDefaults columnDefaults = new MetadataDefaults(customDocumentLibrary);

Now I just need to get my SPFolder object in question and pass it to the meethod SetFieldDefault. This takes a SPFolder object, a string with the name of the SPField to set the default on, and finally the value of the default (in my case “Memo”).

SPFolder testFolder = customDocumentLibrary.RootFolder.SubFolders["Test"];
columnDefaults.SetFieldDefault(testFolder, "DocumentType", "Memo"); 

You can set multiple defaults here. When you’re done, you will need to call .Update().

columnDefaults.Update();

Here is what it all looks like together.

using (SPSite siteCollection = new SPSite("http://sp2010/sites/ECMSource"))
{
    using (SPWeb site = siteCollection.OpenWeb())
    {
        SPList customDocumentLibrary = site.Lists["CustomDocuments"];
        MetadataDefaults columnDefaults = new MetadataDefaults(customDocumentLibrary);
 
        SPFolder testFolder = customDocumentLibrary.RootFolder.SubFolders["Test"];
        columnDefaults.SetFieldDefault(testFolder, "DocumentType", "Memo");
        columnDefaults.Update();
    }
}

You can verify that your property was set correctly on the Change Default Column Values page in your list settings.

This is something that I could see used a lot on an ItemEventReceiver attached to a folder to do metadata inheritance. Whenever, the user changed the value of the folder’s property, you could have it update the default. Your code might look something like this.

columnDefaults.SetFieldDefault(properties.ListItem.Folder, "MyField", properties.ListItem["MyField"].ToString());

This is a great way to keep the child items updated any time the value a folder’s property changes. I’m also wondering if this can be done via CAML. I tried saving a site template, but after importing I got an error on the default values page. I’ll keep looking and let you know what I find out.

A quick look at the SharePoint 2010 Content Organizer

CoreyRoth — Wed, 17 Mar 2010 18:59:00 GMT

I can’t tell you how many SharePoint ECM projects I have seen where there has been a requirement to upload a document somewhere and then move it somewhere else based upon metadata or other criteria. People have written a good amount of code in the past to make this happen. Now with the SharePoint 2010 Content Organizer, the need to write a lot of this code will be gone. Simply put it allows us to create rules that examine the content type and site columns of a document that was uploaded and move it some place else. Surprisingly, I really haven’t heard very many people talking about this. This post will show you how to get started with the Content Organizer using the UI and then my next post will show you how to deploy content organizer rules via CAML. After all, I feel that it is my obligation to always show you how to create things that can easily be moved to your production environment later.

The first place to start is by activating the Content Organizer Site Feature.

Once you activate this feature, a document library called DropOffLibrary is created along with a list called RoutingRules. You will also find two new links in Site Settings: Content Organizer Settings and Content Organizer Rules.

The settings link allows you to configure various things about the content organizer such as forcing all libraries on the site to redirect to the drop-off-library, and allowing you to target rules with destinations on other sites. You can also enable folder partitioning to automatically create subfolders when one container gets too large (user specified limits).

The rules link takes you to the list where you specify the rules. It’s pretty simple really. All rules are based off a content type and then you can specify zero or more conditions based upon site columns on that content type. You can use the priority option to give one rule more importance over another. In this case here, I am creating a rule for the Image content type.

Scrolling down, I can set the condition based upon specific site columns in the content type. In this case, I want to move any image that has a copyright date from last year or earlier into an asset library called Old Assets.

It also has the ability to automatically create subfolders based upon metadata. This is pretty cool. For example I could have it create subfolders for each copyright year. Unfortunately, in Beta 2 this interface has some issues. The dropdownlist never allows me to select a property. Also, selecting certain content types causes it to crash. I also can’t edit an existing rule either. I’m sure all of that has been fixed by now, but it’s something to be aware of if you are trying this out.

Now we need to try it out, I go to the Drop Off Library and use the Add new document link. This library looks a little bit different on a few of the screens.

The user gets a warning that his or her document will be moved. When you add a rule to the organizer that involves a content type, it automatically adds it to the Drop Off Library.

Once we submit, we get a notification of where the document got moved to. Notice that it put it in the Old Assets document library. If there was an issue moving the document or no rules matched, it will leave the document in the Drop Off Library informing the user that it could move in the future.

The only thing I wish it did here was provide a link to the folder of the document as opposed to the document itself.

I really like the content organizer because it allows the user to just upload a document without having to think about where it should go. This makes it much easier for user’s to get their job done and it helps you keep things organized. As someone who does mostly ECM work, this is going to save me a lot of time in the future. Pair this with the new Document Id service and we’ve got a very nice way of dealing with documents. As I mentioned above, I’ll post on how you can import a set of rules using CAML. It’s actually pretty simple.

Metadata Inheritance in SharePoint 2010

CoreyRoth — Mon, 26 Oct 2009 15:09:02 GMT

One new ECM feature that not too many people have talked about is the concept of default values for site columns. It turns out that you can use default values to do metadata inheritance. The way it works is that if you have a custom content types for your folder and child items, you can set default values on the folder and when a new document is created it will automatically set those values on the child content type. We used to have to write code to do this back in MOSS 2007.

After hearing about this new feature, I decided to go to the HOL while I was at SPC and see if I could get it to work. I created two new content types and created a new folder. When I brought up the ECB for the folder I saw a new item that said something to the effect of Set Default Values on this Folder. Here I was able to set values on my site columns. I then uploaded a document to the folder and viewed the properties and sure enough it had the default values I specified. I then used the new document button inside the folder and I noticed that the Document Information Panel did not have the default values. I saved the document to see if they would get set then, but they in fact did not. Now I don’t know if that is a bug or is by design or not. I guess only time will tell.

Either way, I think this is a good start and will definitely eliminate some code we have to write in the future. What I would really like to see next is an option to apply default values to all child items when there is a change (kind of like how you can apply changes to a content type).

New ECM Features in SharePoint 2010

CoreyRoth — Mon, 19 Oct 2009 23:36:23 GMT

MOSS 2007 was a very capable ECM product but there were definitely some things in it that required coding to accomplish. There are five specific areas that are new or that have been improved that are worth mentioning for the world of Enterprise Content Management.

Enterprise Content Types

Enterprise Content Types (or ECTs) solve the problem of having to keep content types synchronized across site collections. Typically, the issue in the past is that you create a content type in one collection and then you also have to updates those content types on all of your other site collections. The power of the ECT is that it allows you to define one site collection as the hub and then the Managed Metadata Service looks at the source site collection and periodically updates all other site collections with any changes.

Document Id Service

Another ECM challenge is keeping track of documents that have gotten moved. The Document Id Service helps with this by generating a unique identifier for every document uploaded. It then stores this URL as metadata on your document and then creates a link passing the id to _layouts/docidredir.aspx.

Managed Metadata (Term Store)

This is a great new feature for ECM and I am afraid my description of it won’t be able to do it justice. The way it works is that there is a new Managed Metadata column that you can add to your content types. There is a place called the term store that allows you to create a hierarchy of terms in something called a term set. This allows you to make relations to things. For example, you could have continents, relate to countries, relate to states, relate to cities. You can have the user specify a value by typing in the field and it searches as you type to find a matching term. The cool part is that this applies to search, so if you search for the state of Washington, you will get documents that were tagged with a value of Redmond. You can also create synonyms for terms for example you could have OKC resolve to Oklahoma City. This is a really powerful new feature that will allow users to make better choices when classifying documents which in turn leads to better search results. There really is a lot more to this, I’ll provide more details on it as I collect more information.

In Place Records Management

I know a handful of people that would say Records Management in MOSS 2007 was pretty much unusable. I think SharePoint 2010 will change their minds. The main issues were that you had to ship documents to an external library to manage them and the interface for applying holds was not very user friendly. Activating the In Place Records Management feature will add a new button, Declare as Record, to the ribbon of document libraries. Clicking this marks the item as a record and I believe puts it in a readonly state. To go along with this, you can activate the Hold and eDiscovery feature which gives you a much nicer way to create and apply holds to records. All of this together gives you the ability to apply holds to documents without ever having to ship them off any where (although you can still send them to an external records center). You can also now schedule a job to move records to the record center on a regular basis. I’ll also point out that there is a new Compliance button on the view properties page of a document. This button allows you view holds, expiration, record status, and auditing. This should make working with records much easier in the future.

Document Sets

SharePoint also now gives you the capability to group documents together in sets that can be worked with as one logical unit. Effectively you create custom document content types and then create a document set content type. The document set has a settings page which allows you to specific which child content types to include It let;s you specify default documents to create when a new document set is created and gives you the capability of synchronizing metadata on shared site columns among the document set and child documents. When you view the document set in a document library, it kind of opens like a folder but displays a page (which can be customized) showing metadata and each child document. It also provides the ability to download the whole set as a zip file. It’s interesting concept and may provide to be quite useful for some types of document collections.

There are some exciting new features in SharePoint 2010 for ECM. I think the Managed Metadata and the In Place Records Management will be highly useful myself. There is obviously more to ECM than what I covered, but I hope these highlights are a good start in learning about the new features.