In this exercise, you'll create a content type for the news articles we will be publishing on our Empire Times web site. We will be building on the Visual Studio solution from the previous chapter.

1. Open your existing EmpireTimes solution.
2. Add a new item of type WSPBuilder Feature with Receiver. Add a name and a description, and make sure you set the scope to Site. I have called my feature TimesContentType.

   Remember the tip from the previous chapter of prepending the name with a token to easily identify features in the [12]TEMPLATEFEATURES folder.

   Also, since we are adding a feature with a receiver, you must remember to remove the exception thrown on FeatureActivated like we did in the previous chapter.

3. Your elements.xml file in the new feature should open automatically. If not, open the elements.xml file.

   Edit the file as such:

   <?xml version="1.0" encoding="utf-8" ?>
<Elements xmlns="http://schemas.microsoft.com/sharepoint/">
  <ContentType ID=""
               Name="News Article"
               Group="EmpireTimes"

               >
  </ContentType>
</Elements>

   You need to add an ID value to the content type to make it work. You may remember from Chapter 8 that the ID of a content type also denotes the content type inheritance. This means the ID requires a bit of crafting.

   To craft the content type ID, you first need to include the Item content type ID. Next you should add a GUID value to the ID string.

4. In the ID attribute, add 0x0100. This denotes that you will be inheriting from the Item root content type and will be adding a complete GUID to make your content type unique.
5. Add a GUID value after the 0x0100 string. The easiest way to do this is to go to the Tools menu and click Create GUID. Click Copy, close the window, and paste the value.
6. In the ID attribute, remove any brackets and hyphens to leave only the numbers and letters. Your ID should look something like this:
   0x0100F2525ACE8DE54912A7A10724466A6A80
7. Build and then deploy or upgrade your solution.
8. Go to your site collection features from the Site Settings page on the root site in your site collection. Activate your feature.
9. Verify that your content type appears in the list. Figure 12-1 shows the result.
   

   Figure 12-1. Content type installed

   At this point, our content type does not contain anything, but, hey, you got it to appear, so something must be right. Right?

In this exercise, you will create a simple content type hierarchy where you will create two specialized child article content types for a stand-alone article and a series article.

1. Open your element.xml file in the TimesContentTypes feature.
2. Add the following CAML code after the existing NewsArticle content type:
   <ContentType ID=""
             Name="Stand-alone article"
             Group="EmpireTimes"

             >
</ContentType>
<ContentType ID=""
             Name="Series article"
             Group="EmpireTimes"

             >
</ContentType>
3. For the ID attributes, copy the ID of the NewsArticle content type, and paste it into the ID of the child content types. Then, add 01 and 02 to the end of the ID value in the child content types. In my example, where the ID of the parent content type is 0x0100F2525ACE8DE54912A7A10724466A6A80, the completed elements.xml file now looks like this:
   <?xml version="1.0" encoding="utf-8" ?>
<Elements xmlns="http://schemas.microsoft.com/sharepoint/">
  <ContentType ID="0x0100F2525ACE8DE54912A7A10724466A6A80"
               Name="NewsArticle"
               Group="EmpireTimes"

               >
  </ContentType>
  <ContentType ID="0x0100F2525ACE8DE54912A7A10724466A6A8001"
               Name="Stand-alone article"
               Group="EmpireTimes"

               >
  </ContentType>
  <ContentType ID="0x0100F2525ACE8DE54912A7A10724466A6A8002"
               Name="Series article"
               Group="EmpireTimes"

               >
  </ContentType>
</Elements>
4. Build and then deploy or upgrade. Deactivate and then reactivate the feature from site collection features. Verify that your new content types appear in the Site Content Types Gallery. Your result should be like Figure 12-2. Notice that each of the child content types is correctly shown to inherit from the NewsArticle parent type.
   

   Figure 12-2. Simple content type hierarchy

   Still, the content types do not actually do anything. Patience. We will get there shortly.

What you will do now is add the site columns you created in the previous chapter to the parent content type and see what happens. If you haven't created the site columns in the previous chapter, now would be a good time.

1. Open the elements.xml file from the site columns feature created in the previous chapter.
2. In your elements.xml file for the TimesContentTypes feature, add a child element FieldRefs to the parent content type NewsArticle:
   <ContentType ID="0x0100F2525ACE8DE54912A7A10724466A6A80"
             Name="NewsArticle"
             Group="EmpireTimes"

             >
  <FieldRefs>
  </FieldRefs>
</ContentType>
3. Inside the FieldRefs element, add FieldRef child elements for each of the site columns we created in the previous chapter. You should end up with five FieldRef elements something like this:
   <FieldRefs>
  <FieldRef ID="{D4A9AEE0-5559-47a5-A8A7-019D5150556C}" />
  <FieldRef ID="{A9D43B6B-F6D8-4938-B545-0465AB696F97}"/>
  <FieldRef ID="{7439066B-E58A-448a-9BF7-73BE426150DD}"/>
  <FieldRef ID="{B3A86425-7C09-4574-B181-B94E2DA3A07D}"/>
  <FieldRef ID="{79292857-5275-4f45-8A3C-AF482F9FC565}"/>
</FieldRefs>

   The ID values may vary if you created your own GUID values for the site columns. Just make sure your ID values correspond to the site columns you created in the previous chapter.

4. Build, deploy…yada, yada…check to see what has happened to the NewsArticle content type. Figure 12-3 shows my results.
   

   Figure 12-3. Woo-hoo, we added some site columns. Go, you.

   Everything looks just as it should. You are hereby awarded the title of “content type deployer”—a highly sought title, I am sure.

In this exercise, you will fix the broken content type column inheritance.

1. Modify your child content types, and add an empty FieldRefs element to each:
   <ContentType ID="0x0100F2525ACE8DE54912A7A10724466A6A8001"
             Name="Stand-alone article"
             Group="EmpireTimes"

           >
  <FieldRefs></FieldRefs>
</ContentType>
<!-—Repeat for Series article content type-->

   That's it. Nothing more. Do the build, deploy, deactivate, reactivate cycle, and, kaboom, Bob's your uncle. Again. He might even reinstate your inheritance.

   I made this error quite a lot when I started out doing content type inheritance through code. Now you don't have to.

   Check out Figure 12-5.

   

   Figure 12-5. Now that's more like it!

In this exercise, you will create a new rendering template for the content types you created earlier in the chapter. Then you will attach that rendering template to the various forms used to render the content type data. WSPBuilder will handle correct deployment of the code as long as you place it in the correct structure in your solution.

1. You should have a folder called 12TEMPLATESCONTROLTEMPLATES in your solution already. If not, create it.

   Mimicking the [12] structure will help WSPBuilder place your files in the correct directories when you deploy.

2. In the CONTROLTEMPLATES folder, add a new text file called TimesListForms.ascx.

   Why a text file? Well, the project is not a web project, so you don't have the option of adding a web user control. Naming the file .ascx will still tell Visual Studio that you want a control, however.

3. From the [12]TEMPLATESCONTROLTEMPLATES directory in your SharePoint installation, open the DefaultTemplates.ascx file.
4. Copy the directives at the top of the DefaultTemplates.ascx file, and paste them into your own TimesListForms.ascx. That would be all the lines starting with <%@.
5. In the DefaultTemplates.ascx file, locate the ListForm rendering template. Copy the rendering template, starting with the <SharePoint:RenderingTemplate ID="ListForm" runat="server"> tag and ending with the next </SharePoint:RenderingTemplate> tag. Paste it into your TimesListForms.ascx file.
6. In the TimesListForms.ascx, modify the ID of the rendering template from ID="ListForm" to ID="EmpireTimesNewsDisplayForm". Figure 12-6 shows an excerpt of what the final code should look like.
   

   Figure 12-6. Rendering template excerpt

7. Modify the rendering template to match the design of your favorite newspaper web site. Remember to include relative image references and download all supporting scripts and CSS files. Build, deploy, and test.

   Yeah, that last item was a joke.

   The point is, adding the listing of a complete design of a web site to a book like this makes no sense, and we are short on space already. As such:

8. If you are reading this while offline, make some kind of random change to the rendering template. If you are reading this while online, you can go to the book's downloads and download a sample design. The URL for this sample is http://www.understandingsharepoint.com/url/20002.

   OK, next you update the content types to use your new display form.

9. Open the elements.xml file of the TimesContentTypes feature. In the NewsArticle content type, add the following XmlDocument content after the FieldRefs element:
   <XmlDocuments>
  <XmlDocument</code>
NamespaceURI="http://schemas.microsoft.com/sharepoint/v3/contenttype/forms">
    <FormTemplates</code>
xmlns="http://schemas.microsoft.com/sharepoint/v3/contenttype/forms">
      <Display>EmpireTimesNewsDisplayForm</Display>
      <Edit>ListForm</Edit>
      <New>ListForm</New>
    </FormTemplates>
  </XmlDocument>
</XmlDocuments>
10. Reactivate, deactivate, deploy, and build your solution. In reverse order. While blindfolded. You should know this routine by now.

    Right, that should be it.

In this optional exercise, you will test the content type and make sure it displays correctly.

1. Create a new custom list. Enable content type management from the Advanced settings on the List Settings page.
2. (Optional) After enabling content type management, go back to the List Settings page. Click the Item content type, and then delete it.

   Yes, I said delete it. Remember, list content types are just copies of the parent type. Deleting the Item content type here affects only the current list.

3. Click “Add from existing site content types.” Find the “Stand-alone article” content type, and add it to the list before clicking OK. If you select EmpireTimes from the drop-down list above the lists, you may find the correct content type faster (see Figure 12-7).
   

   Figure 12-7. Adding a content type to a list

4. Go back to the list, and add a new item. Note that you have not yet edited the NewForm or our content type, so you just get the standard SharePoint ListForm template.
5. Open your new item. Depending on whether you downloaded the sample design, you should see something like Figure 12-8.
   

   Figure 12-8. Your great new display form. Yeah, I misspelled stuff, which is inevitable proof that even I make mistakes. It has happened before; once, in 1998, I took a wrong turn at an intersection.

   Cool, eh? Let's get moving again.

In this exercise, you will create two event receivers and attach them to the content types you have created.

1. Add a new class file, for example, in the FeatureCode folder of your solution. Name it something cool, such as TimesNewsEventReceivers.cs. Open the file.

   Note that if you add the class file to the FeatureCode folder, Visual Studio will add FeatureCode to your namespace. You do not want that.

2. Add a using Microsoft.Sharepoint; statement to the file.
3. Have your class inherit from the SPItemEventReceiver class. Oh, and make the class public. It sort of works best that way. At this point, your file should look something like this:
   using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.SharePoint;

namespace EmpireTimes
{
    public class TimesNewsEventReceivers : SPItemEventReceiver
    {

    }
}
4. Override the ItemUpdating method. Add the following code to your overridden method:
   public override void ItemUpdating(SPItemEventProperties properties)
{
    SPListItem item = properties.ListItem;
    SPFieldLookupValue newValue =
        new SPFieldLookupValue(item["ArticleCategory"].ToString());

    if (newValue.LookupId.ToString() !=
        properties.AfterProperties["ArticleCategory"].ToString())
    {
        properties.ErrorMessage = "You cannot change category";
        properties.Cancel = true;
    }

}

   This method handles the changing of article category. Now we want to avoid deletion of news.

5. Override the ItemDeleting method. Add the following code to your overridden method:
   public override void ItemDeleting(SPItemEventProperties properties)
{

    properties.Cancel = true;
    properties.ErrorMessage =
        "Cannot delete news. If it happened, it happened.";
}

   That takes care of deleting news. Feel free to argue that the editor is an idiot for refusing to delete items, but, hey, I didn't make the rules.

   Next we need to attach the event receiver to the content type. To do so, as you may remember, we need to add an XML document to the content type.

6. Update the NewsArticle root content type, and add an XML document to the XmlDocuments element as such:
   <XmlDocument NamespaceURI="http://schemas.microsoft.com/sharepoint/events">
  <spe:Receivers xmlns:spe="http://schemas.microsoft.com/sharepoint/events">
    <Receiver>
      <Name>Updating news article</Name>
      <Type>ItemUpdating</Type>
      <SequenceNumber>1</SequenceNumber>
      <Assembly>EmpireTimes, Version=1.0.0.0, Culture=neutral,
 PublicKeyToken=[YOUR PUBLIC KEY TOKEN]</Assembly>
      <Class>EmpireTimes.TimesNewsEventReceivers</Class>
      <Data />
      <Filter />
  </Receiver>
  <Receiver>
    <Name>Deleting news article</Name>
      <Type>ItemDeleting</Type>
      <SequenceNumber>1</SequenceNumber>
      <Assembly>EmpireTimes, Version=1.0.0.0, Culture=neutral,
 PublicKeyToken=[YOUR PUBLIC KEY TOKEN]</Assembly>
      <Class>EmpireTimes.TimesNewsEventReceivers</Class>
      <Data />
      <Filter />
    </Receiver>
  </spe:Receivers>
</XmlDocument>

   Note that [YOUR PUBLIC KEY TOKEN] must be replaced with the public key token for your solution. If you're using WSPBuilder, the easiest way to get this value is to check the Feature.xml file of your feature because this will contain the public key token.

7. Build and then deploy or upgrade your solution. Deactivate and reactivate the feature.

   Note that if you added the content type to a list in the optional exercise earlier, you must remove and re-add the content type to the list for the changes to take effect.

In this exercise, you will create a Submit for Editor action that is connected to the stand-alone news article content type. You will do this by creating a CustomAction element and connecting that to the content type using the RegistrationType and RegistrationId attributes of the CustomAction element. You will then make the CustomAction appear on the EditControlBlock of items based on the stand-alone news article content type.

1. In the feature.xml file of TimesContentTypes, add the following line to the ElementManifests element:
   <ElementManifests>
  <ElementManifest Location="elements.xml"/>
  <ElementManifest Location="customaction.xml"/>
</ElementManifests>

   I'm having you put the custom action in a separate elements file to keep things tidy and to point out that you can indeed have several element files in the same feature.

2. Create a new XML file in the TimesContentTypes folder, called customaction.xml.
3. In the customaction.xml file, add the following code:
        <?xml version="1.0" encoding="utf-8" ?>
     <Elements xmlns="http://schemas.microsoft.com/sharepoint/">

</Elements>
4. Add a CustomAction element inside the Element element of your new element's customaction.xml element file. And if you mention element again….
   <CustomAction Location=""
              RegistrationType="ContentType"
              RegistrationId=""
              Title="Submit article to editor"

              >
  <UrlAction Url="submitarticle.aspx"/>
</CustomAction>

   Notice that as you complete typing the RegistrationType attribute, you get IntelliSense for the values, as shown here.

   

   As you learned in Chapter 5, GroupId and Location are the attributes that decide where your CustomAction will appear. However, for the EditControlBlock, we do not need a GroupId at all. So:

5. Update the Location attribute as such:
   Location="EditControlBlock"
6. Enter the content type ID for your stand-alone article in the RegistrationId attribute. You'll find the content type ID in your other elements.xml file in the TimesContentTypes feature.

   You have added a UrlAction child element pointing to submitarticle.aspx. This page doesn't exist, so the link won't actually work. We will explore how you can create such custom pages in Chapter 14.

   However, to know which article you actually want to submit, you need to pass an argument to the submitarticle. aspx page. To do this, you can include tokens as part of the Url attribute or UrlAction.

7. Update the Url attribute of the UrlAction element as such:
   <UrlAction Url="submitpage.aspx?Article={ItemId}&List={ListId}"/>

   The {ItemId} token will be replaced at runtime with the item's ID. This ID, however, is unique only within a list. So, to make sure you know exactly which item is submitted, you also need to include the {ListId} token.

   Since the submitpage.aspx page does not exist, you will get an error if you try to click the “Submit to editor” link in the context menu. One tip to test that you have actually entered the correct values in the Url action before the page is complete is to surround the Url with a javascript:alert().

8. (Optional) Edit the UrlAction element as such:
   <UrlAction
Url="javascript:alert('submitpage.aspx?Article={ItemId}&List={ListId}'),"/>

   Build but pause for a second. When you add new files to a solution, as is the case here, you cannot upgrade the solution, because upgrading a solution will upgrade only existing files. Instead, uninstall your existing solution before you install. Then, activate the content types feature as you did before.

   Figure 12-9 shows my results.

   That's really how easy this is. Of course, everything is easy when you know how, and now you know. Good, you!

   

   Figure 12-9. EditControlBlock CustomAction tied to a content type