Rich Finn - WSP Development

Building Solutions (WSP) in Visual Studio? Say hello to SPSource...

Wed, 13 Aug 2008 23:13:21 GMT

Creating Features which contain custom Content Types or file provisioning modules requires developers to write a lot of XML based on the wss.xsd. Content types require custom column and content type definition files, along with the proper creation of the content type IDs. File provisioning modules require the creation of module elements which contain the information that will help properly push the files into the correct lists when the Feature is activated.

This XML can be fairly daunting, time consuming, and frankly, not very exciting for developers who just want to test their code. This holds especially true for developers who are writing custom Features based on SharePoint's Publishing Feature, and this is why I created SPSource.

SPSource helps by alleviating the need for developers to write these files by allowing them to use the SharePoint UI and SharePoint Designer (SPD) as the source for the files defined in the module elements, along with custom content types, and is meant to be integrated with (and has been tested with) WSP creation tools such as WSPBuilder, STSDev, and the WSPProjectTemplate as either part of the build process, or separately as a CMD file at the root of the project. By using the UI and SPD, items can be created and tested rapidly, then compiled into the WSP for deployment using familiar tools.

Executing BEFORE the creation of the WSP, any file that can be created using SharePoint Designer in a document library, and any site content type created in the SharePoint UI can be targeted and pulled down into Visual Studio for addition in a pre-existing Visual Studio WSP project. SPSource will also create the file provisioning modules and site Content Type/Column definition files, as well as the lines needed in the ElementManifest section of the Feature.xml file.

Some examples of how SPSource can help:

Completely define a custom Publishing Feature using SPD and the SharePoint UI, creating the master pages, page layouts, content types, style sheets, and images directly in the content database. Once at a point where it's ready for deployment, run SPSource against the project and pull everything into a pre-existing WSP. If changes are needed in the markup, make them using SPD, and re-run SPSource. The files in the WSP will be updated and ready for a solution upgrade.

Implement a class on an ASPX page (code behind) in SPD, and code that class in Visual Studio, or add custom server controls to the markup in SPD. Push your assembly directly to the GAC or bin as part of the build process, and the code-to-test time is much faster, as the markup files are already in the content database. Once everything is set, run SPSource again the project, and pull everything together into the WSP.

Add a custom Content Query Web Part (or RSS) .webpart file to the web part gallery, and change the properties and settings for the new CQWP via the UI and SPD to use custom XSL files that you add to the Style Library/XSL Style Sheets folder. Create new ItemStyles, change the Headers, or add new parameters to the Main XSL. The XSL files can be updated quickly using SPD, and changes can be seen right away. When all is ready for integration into the WSP, execute SPSource against the new files and create a new Feature for the new web part in minutes.

Eventually, I hope to get SPSource working with ListInstances and Workflows, but for right now, it only works with Content Types and Modules.

Check out this screencast where I create a custom Publishing Feature, with a new content type and page layout, execute SPSource on my StsDev Visual Studio project, package it all up in a WSP, and deploy in less than 15 minutes!

SPSource Publishing Feature Demo

Here's a short walk-through example of how SPSource works:

In the 'design' site, create a new Content Type for a Publishing page using the SharePoint UI, adding some new columns

In SharePoint Designer, create a new Page Layout based on the Content Type which was just created

Still in SharePoint Designer, add the new content field controls, a web part zone, and some other markup to the new Page Layout, saving it to the 'design' site Master Page Gallery

Now, over in a Visual Studio project, which in this example is based on StsDev, create a new Feature, and create some new Folders in that Feature. The folders aren't important in this case, they just allow for some organization. SPSource has been tested using WSPBuilder, StsDEv, and WspProjectTemplate, but the type of project in Visual Studio really doesn't matter. It just needs to follow the 12Hive folder structure, which means SPSource does not work with VSEWSS.

In each folder, create a new file with the file extension '.spsource'. This file extension is important, as the SPSource utility looks for these files to work it's magic. The SPSource files are nothing more than a type of XML file and are what I call 'reverse manifests' as they are based on the same syntax used to push things into SharePoint, but in the case of SPSource, are used to get things out of SharePoint.

The SPSource file for the Content Type is just like a Content Type definition file, and is even based on the same schema. All we need is the name of the custom Content Type we want to have included in the WSP

The SPSource file for the custom Page Layout is also just like a provisioning module file used to put files into SharePoint. We just need to tell it the source list URL, and the file to include in the WSP

At the root of the Visual Studio project, I've got a CMD file that contains the information needed to execute SPSource

Source of CMD file

After SPSource is executed, there will be some new files in your Visual Studio project.

In the ContentType folder, there are now files for both the Content Type definition, as well as the column definitions.
Content Type definition:

Column definition:

The ASPX page in the PageLayouts folder is the same as what we added in SharePoint designer

The pagelayouts.Provisioner.xml file is the provisioning module file needed to put the custom Page Layout in to the correct location when the Feature is activated

The two *.ElementManifest.xml files are there so you have the lines needed to add to the Feature.xml file in the ElementManfiests section. These lines are not automatically added to the Feature.xml as to provide greater flexibility by you to distinguish what gets included in the Feature.

After I add the lines to the Feature file:

Now I can build my project to compile the WSP and deploy it to the 'development' site. SPSource can also be integrated with the MSBuild process to allow for updates to the files added by SPSource before the WSP is compiled. This allows the WSP to be upgraded using items changed in the UI and SharePoint Designer.

After the solution is built and deployed, the Feature can be activated, and the pages will be added to the Master Page Gallery

Master Page Gallery

When I create a new page, the new Page Layout is available in the list, as expected

and, the page looks the way it should

Give SPSource a try, and see how much more efficient your Visual Studio WSP creation process can be!

Enable Workflow development in a class library project being used to create a WSSv3 Solution

Fri, 28 Dec 2007 22:05:56 GMT

When creating a WSP in WSSv3, the common development practice is to create a project in Visual Studio using the Class Library project template. The problem with this is that none of the Workflow item templates are present when you try and add a new item, so how can you add a Workflow without having a one-off Visual Studio project just for your Workflow Feature?

The answer is that you need to make some changes to the project file in Visual Studio to make it happen. The project file (YourProject.csproj - for example) is the file which tells the IDE what files, references, folders, etc. are present so that when the project is built, MSBuild knows how to compile the assembly correctly.

The steps I'll walk you through are intended for Visual Studio 2005. You need to make sure you have the latest version of the Office Server SDK available from MSDN. The steps are pretty much identical for Visual Studio 2008, you just need to make sure you change the targeted version of the .NET Framework to be version 3.0.

First thing - if you have the project under source control, you want to make sure the project file is checked out or else you won't be able to edit it.

Now, you want to unload the project in the IDE. To do this, right-click the project and choose 'Unload Project'

Once the project has been unloaded, right-click the project again and choose 'Edit YOURPROJECT.csproj' This will open the project file for editing in Visual Studio.

Locate the first PropertyGroup in the file at the top, and paste in the following code

<ProjectTypeGuids>{14822709-B5A1-4724-98CA-57A101D1B079};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>

as shown below

Now you need to make sure that the proper references are included

Locate the ItemGroup in the project file with the references

Paste in the following references after the last reference in the ItemGroup

<Reference Include="microsoft.office.workflow.tasks"/> <Reference Include="Microsoft.Sharepoint.WorkflowActions"/> <Reference Include="System.Workflow.Activities" /> <Reference Include="System.Workflow.ComponentModel" /> <Reference Include="System.Workflow.Runtime" /> <!--
you probably already have the following --> <Reference Include="Microsoft.SharePoint"/>

Save the project file and reload the project

Now you have the Workflow item templates available, along with the support of the Workflow designer.

The final step is to change the base class for the Workflows you create.

If you are creating a Sequential Workflow, you need to make sure the workflow class inherits from Microsoft.SharePoint.WorkflowActions.SharePointSequentialWorkflowActivity. This will enable the SharePoint Workflow Activities in the Visual Studio Toolbox. There is no base class for the SharePoint State Machine workflow other than the standard System.Workflow.Activities.StateMachineWorkflowActivity.

>
The one main piece of advice I have is to make sure you set the base class of the Workflow class before you start working on it. When you change the base class, all child activities will be removed from the Workflow. At least they were removed for me!

Creating and deploying a Custom Site Definition as a feature

Sun, 23 Sep 2007 16:42:25 GMT

Ok, so you really don't develop a custom site definition as a Feature in the WSSv3 sense of the word 'feature', but you can create a solution package which contains all the needed pieces for the custom site definition, including any Features you want activated on the site when it's first created.

While there's plenty of documentation around creating custom site definitions out there, I figured it would be beneficial to explain the steps needed to create the solution and deploy everything as a a single entity into WSSv3 as a WSP.

For this example, I'm going to create a custom version of the Team Site template without any significant changes because I don't want to deep dive into how to create a custom site definition.   I'm then going to add a Label control to the default.aspx and populate it's value in a new code-code behind class for the default.aspx page that's not included out of the box.

While I don't like forcing an install any anyone, I'm going to use the Visual Studio 2005 project template I created which will take care of most of the tricky pieces that are required to create and deploy the solution This thing really does make custom solution development using Visual Studio for WSS a snap. Please download it and check it out.

Once you've installed the Visual Studio project template correctly, create a new project using the MOSS Solution Builder Project template. For this example, I named the project Example.CustomSiteSolution.

After the project has been created, you should sign the assembly using your own key file, but for the sake of this example, I'm going to leave the temp.snk file where it is.

Build the project. This will ensure that the assembly is in place so we can get the public key token using the sn.exe -T method. Once you have the public key token, replace the [Your_PKT] placeholder in the ManifestTemplate.xml file.

Navigate in Windows Explorer to \12\TEMPLATE\1033\XML. The xml files here contain the information needed by WSS to know what templates are available for sites to be created. Bill Baer has a good post on understanding the webtemp files if you want to know more about the specifics and the schema.

Since we're going to be creating a custom version of the Team Site template, copy the webtemp.xml file, and paste it into the \TEMPLATE\1033\XML directory of your VS project. Rename it to 'webtemp.customsitesolution.xml'. The new name doesn't matter too much other than that it has to start with webtemp, but it's a good idea to have it relate to the solution to which it's attached.

Open the xml file and delete all the Template elements except for the one with the Name="STS". Change the name to be CustomSiteExample, and change the ID to a number over 10000. Also delete the other Configuration elements except for the first one with the ID of 0. You can also change the name and description of the configuration element to be whatever you want.

The final version of the file should look like this:

<?xml version="1.0" encoding="utf-8"?>   <Templates xmlns:ows="Microsoft SharePoint"> <Template Name="CustomSiteExample" ID="111000"> <Configuration ID="0" Title="Custom Site Exmaple Site" Hidden="FALSE" ImageUrl="/_layouts/images/stsprev.png" Description="An example site for learning to create a new site definition." DisplayCategory="Collaboration" > </Configuration> </Template> </Templates>

NOTE: Dang, I made a mistake in my original VS template. I had originally named the SiteTemplates directory 'SiteDefinitions'. If you've downloaded the VS template since 9/23, this has been fixed. If you got the template before then, renaming the SiteDefinitions folder to be SiteTemplates works, or you can download and install it again. Whoops...

Now navigate in Windows Explorer to \12\TEMPLATE\SiteTemplates. All of the folders in here are the site templates. Because we are creating a copy of the Team site template, copy the 'sts' folder - the Team Site definition - into the Template\SiteTemplates directory of the VS project and rename it to match the Name attribute value of the webtemp.customsitesolution.xml file, which I named CustomSiteExample, as shown above.

The directory structure of the project should now look like this:

Open the onet.xml file in TEMPLATE\SiteDefinitions\CustomSiteExample\xml of your VS project. This is the primary configuration file of the site definition. (I hear that onet stands for Office.NET, in case you're wondering.) To make this next part a little more manageable, collapse the primary nodes of the xml file so that it looks like this:

One of the first things I like to do in onet is add a new attribute to the Project element. Adding ' xmlns="http://schemas.microsoft.com/sharepoint/" ' to the element will give you Intellisence in the onet file - a huge help.

Change the /Project[@Title] value to be 'Custom Site Definition'

Expand the Configurations section and delete all of the Configuration nodes except for IDs -1 and 0

The /Project/Configurations/Configuration[@ID=0] node corresponds with the /Templates/Template[@ID=0] node we have in the webtemp.customsitesolution.xml file. If you want to create other custom site definitions that are similar to the one we're creating first, then all you need to do is create a new Configuration node with ID=1 in both the webtemp file and the onet file.

Next, expand the Modules element (/Project/Modules NOT /Project/Configuration[@ID=0]/Modules), and delete all of the Module elements except for the one where @Name=Default.

Essentially, that's it for creating the custom site definition. If you wanted to deploy the solution as it is right now, you'd have an exact replica of the Team Site template, with a different name. By building your Visual Studio project, having used the MOSS Solution Builder Project template, all the pieces are in the right place for creating a WSP file, and you should have a file named Exmapl.CustomSiteSolution.wsp in the /wsp directory of the project, as shown below.

Now, to create a code behind file for the default.aspx page that is included in the site definition.

In the CreateSiteExample folder in Visual Studio, create a new class file named default.aspx.cs. It should sit right next to default.aspx. Change the namespace to Example.CustomSiteSolution.CustomSiteExample. Change the name of the class from @default to _default.

Make the page inherit from WebPartPage by adding ' : WebPartPage' after the class name so that the file looks like this:

Here's a neat little trick: See the little red box beneath WebPartPage? That means that Visual Studio wants to help you out using a little love from the built-in Refactoring functionality. Whenever you see this, press Shift+Alt+F10. A little menu will open with the refactoring options available. In this case, because we have a reference to Microsoft.SharePoint, Visual Studio wants to add out using statement for us.

Now we need to add this namespace to the manifest.xml in the SafeControls section so the code will be allowed to run in the SharePoint context, so we need to add it to the SafeControls section of the ManifestTemplate.xml file, which will now look like this:

<SafeControls> <SafeControl Safe="True"
       Assembly="Example.CustomSiteSolution, Version=1.0.0.0, Culture=neutral, PublicKeyToken=ef72d5cefb9f703d"

Namespace="Example.CustomSiteSolution" TypeName="*"/> <SafeControl Safe="True"

Assembly="Example.CustomSiteSolution, Version=1.0.0.0, Culture=neutral, PublicKeyToken=ef72d5cefb9f703d"

Namespace="Example.CustomSiteSolution.CustomSiteExample" TypeName="*"/> </SafeControls>

When the project is built, the ManifestTemplate.xml is merged with auto-generated files to create the manifest.xml needed for the solution.

In the default.aspx, locate the Page directive at the top of the page. It should look like this:

<%@ Page language="C#" MasterPageFile="~masterurl/default.master" Inherits="Microsoft.SharePoint.WebPartPages.WebPartPage,Microsoft.SharePoint,Version=12.0.0.0,Culture=neutral,PublicKeyToken=71e9bce111e9429c" %>

Change the Inherits attribute value to be "Example.CustomSiteSolution.CustomSiteExample._default." This ties the page to the new code behind file.

Place a asp:Label control named lblBreadCrumbHello right before the breadcrumb control so that it looks like this:

In the default.aspx.cs class, declare the Label control in the class like this:

This is similar to the way the .designer files work in the Asp.Net Web Application projects, but we have to add them by hand in WSS development. I wouldn't be surprised if WSS development in Visual Studio eventually works just like Asp.Net application projects, but until then, this isn't that bad.

Now, create a method to handle the Page_Load event in the class, and populate the asp:label control like this:

When you create a site, the breadcrumb should look like this:

That's it! Now let's deploy the solution...

To deploy, open both the deploy.cmd and upgrade.cmd files in the DeploymentScripts directory of your VS project. At the top, there's a line that looks like this:

Change the value of SITE_URL to be the URL of your site you want to deploy the solution to. Do the same for the upgrade.cmd file while you're at it.

To deploy the solution, navigate in Windows Explorer to the DeploymentScripts directory for the project. Double-click deploy.cmd to execute the deployment command. You might see an error the first time you deply saying that the solution is not in the solution store because the deployment script tries to delete the solution from the solution store first. This is needed because if you add new features to the solution, you needed to execute the deploysolution operation of stsadm in order for the features to be installed correctly.

If you are not adding new features, you can execute the upgrade.cmd file. This file updates the files on the server with the latest versions, as well as updating the assembly with any code changes. Chris O' Brian has a good post on adding features to site definitions.

After you deploy the solution for the first time, even though the ResetWebServer attribute in the manifest.xml is set to true, it's a good idea to run IISReset on the WFE servers to ensure that the new site definition is picked up. You shouldn't have to do this for subsequent deployments.

When you choose to create a new site, you should see the new site definition in the list of available templates:

There, a custom site definition deployed as a solution (using the Visual Studio Solution Project template) to all WFE servers running in your farm - one of the joys of solutions. Quick and easy, hopefully...

Visual Studio 2005 template (with installer) for building MOSS Solution Packages

Wed, 19 Sep 2007 23:00:37 GMT

A while ago, I released my little executable for creating WSPs that could be incorporated into the build process of Visual Studio 2005 similar to Carsten Keutmann's WSPBuilder. The downfall was that there was a lot of configuration you had to do to get it working. So, now I've created a Visual Studio project template which is pre-configured with all the needed elements for building the WSP. All you need to to is use the choose the project template and build.

Here's what you need to get going...

1) Download the installer for the template onto your MOSS development server. When you run the exe, it will unpack to c:\createddf, and you'll see a console window open saying 'Configuring Visual Studio, please wait...'. Don't delete or move the c:\createddf directory!

2) Close Visual Studio and re-open

3) Create a new project, and choose the MOSS Solution Builder Project template from the SharePoint_RF project type group. Make sure to name your project with no spaces...

4) The solution explorer should look like this once the project opens (click img to expand):

There is a temp.snk file which will be used to sign your assembly unless you change it, which you should.

5) Build the project

7) Open ManifestTemplate.xml
- The solution guid is unique for this solution
- This file is your handle on having control over what's in the manifest.xml file in the wsp. If you want other namespaces to be included in the safe controls section, put them in. The same rules apply as in the previous wsp packaging tool I created earlier.

8) Open the deploy.cmd file in the DeploymentScripts directory. Change the SITE_URL variable to be the address of the web application you want to deploy the solution to.

9) Navigate to the DeploymentScripts directory in Windows Explorer, and double-click deploy.cmd. Make sure you have the stsadm directory added to your path environment variables. You could also create an external tool in Visual Stuido so you never need to leave the IDE.

The first time you run the deploy.cmd, you might see an error saying that the solution does not exist in the solution store. Just hit enter. The deploy.cmd tries to delete, then add, then deploy the solution. You can tweak the file so that features are activated, as well. There's an upgrade.cmd for upgrading your solution, as well. Just make sure you remember to change the SITE_URL variable.

If you have any questions, please ask.

Enjoy!

Update (10/18/2007)

Released a newer version of the template, here's some of the updates:

1) I took out the sample pages from the layouts directory because I wasn't able to achieve exactly what I was trying to do. Essentially, I was trying to demonstrate how to have ASPX and ASCX files with code behind, but I just didn't like how it was sitting in the template. I explain how to do the same thing in my post on deploying a site definition as a feature, and Andrew Connell explains how to on his blog, too.

2) The ManifestTemplate.xml file was changed so that you no longer need to worry about putting the public key token into the file. The [ThisAssemblyName] placeholder in the file is replaced with the correct information when you build the project after you sign it. Once you sign the project, you need to build the project twice, as the signing process takes too long, and the assembly full name isn't yet available. Once it is, you can build it normally from then on.

3) You don't need to worry about adding features to the FeatureManifest section in ManifestTemplate.xml. In fact, you don't need a FeatureManifest section in ManifestTemplate at all. Custom features in the Features directory of the project will have their feature.xml files added to the manifest.xml output by the build. If you don't want a feature included in the manifest, add '.exclude' to the custom feature's directory name.

4) If you want other assemblies included in the wsp, like non-GAC'd assemblies or 3rd party assemblies, you can add them to the Assemblies directory in your project. They will get added to the root of the wsp, but you need to add the appropriate assembly lines in the ManifestTemplate.xml file.

Support for Visual Studio 2008:

Execute InstallWSPBuilder.exe in c:\createddf via command line, but add the parameter '/2008'. This will set up the template in VS08.

Create DDF/WSP Tool - now with Manifest!

Thu, 30 Aug 2007 17:14:25 GMT

Yesterday, I released a little tool that creates the ddf and wsp files as part of the vs build process. The downfall was that you still had to manage all those templatefile lines in the manifest file. This morning, I fixed that.

The way the app works now is that it looks for a file in your project called ManifestTemplate.xml. Because there are so many different things you can do in the manifest, I didn't want to take control away from being able to customize the manifest file. Maybe you have multiple assemblies you want to include, or you have resource files. I'm just concerned about the TemplateFiles section right now because it can get pretty overwhelming.

The ManifestTemplate.xml file is essentially exactly like your old manifest.xml, just without the TemplateFiles section. This tool takes ManifestTemplate.xml, and through the same process used to create the ddf file, appends the TemplateFiles section to it with all the needed child TemplateFile nodes, and outputs the manifest.xml file to the root of your project. This way you still have complete control over what's going on in the manifest, but can add and remove files from the template directory all you want.

Here's the build process steps:
1) Dev builds project
2) ManifestTemplate.xml is transformed to manifest.xml with all TemplateFiles included
3) Manifest.xml file created at root of project
4) DDF file created at root of project
5) Assembly is compiled
6) WSP file created in /wsp directory

View Codeplex Site for executable and source code

Check out the post yesterday for installation and configuration instructions

Latest release notes:
- Better error handling than yesterday
- Don't want a file included in the solution, add '.exclude' to the filename
- Files in the root directory of a feature (ie:/Template/FEATURES/featurename) are excluded, as those files should be in Feature.xml's ElementManifests section
- resx files or files included in a directory named Resources are included in the ddf, but not in template files, as those should be in the RootFiles or Resources section
- ListTemplate files for a custom list definition, if included in a directory named ListTemplates, are also not included in the TemplateFiles section of the manifest. These files should be in the list definition's Feature.xml. Any other files in the ListTemplates directory are excluded.

Update(9/23/07): I've created a Visual Studio 2005 project tempate for wsp development. Check it out!

Example ManifestTemplate.xml (same as manifest.xml,but no template files section):

<Solution SolutionId="3ECF115B-B0C1-457e-87DB-D844FB763775" xmlns="http://schemas.microsoft.com/sharepoint/" ResetWebServer="TRUE"> <Assemblies> <Assembly DeploymentTarget="GlobalAssemblyCache" Location="assembly.dll"> <SafeControls> <SafeControl Safe="True" Assembly="assembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=[your pkt]" Namespace="assembly" TypeName="*"/> <SafeControl Safe="True" Assembly="assembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=[your pkt]" Namespace="assembly.ServerControls" TypeName="*"/> </Assembly> <Assembly DeploymentTarget="GlobalAssemblyCache" Location="3rdParty.dll"> <SafeControls> <SafeControl Safe="True" Assembly="3rdParty, Version=4.3.8.0, Culture=neutral, PublicKeyToken=kjh2kh32kjh21j" Namespace="3rdParty.WebControls" TypeName="*"/> </SafeControls> </Assembly> </Assemblies> <Resources> <Resource Location="CustomResources\CustomResources.en-US.resx"/> <Resource Location="CustomResources\CustomResources.resx"/> </Resources> <FeatureManifests> <FeatureManifest Location="CustomFeature1\Feature.xml"/> <FeatureManifest Location="CustomFeature2\Feature.xml"/> </FeatureManifests> <RootFiles> <RootFile Location="CustomResources\CustomResources.en-US.resx"/> <RootFile Location="CustomResources\CustomResources.resx"/> </RootFiles> </Solution>

Create DDF and WSP by building your Visual Studio project

Wed, 29 Aug 2007 18:06:25 GMT

After wasting so much time by forgetting to add files to the ddf file (and just messing with the ddf file in general) I said to myself, there HAS to be a better way to do this DDF into WSP thing! So this morning I created a little program in an hour and a half that creates my ddf file and then packages everything up into a wsp for me. All I need to do is build my project. I figured I'd share this tool, so here it is...

Visit Codeplex site for source and executables

The most effective way to set up the Visual Studio environment for wsp development I've found is to set up your folder structure to mirror the Templates directory in the 12 hive, so this tool assumes that's what you're doing, too.

If you have your project set up this way, this tool will go through the Template directory of your project and pull out all the files that are not either a .CS or a .SSC (source safe file). If you get the source of this tool, you can see how the file exclusions are managed and add your own.

The one downfall right now is that this tool won't create the manifest.xml file for you. I'd like to get to that eventually, but there was just too much complexity in the way the manifest file works to do the whole thing in under two hours.

Install instructions:
1) Either get the executable or build the project
2) Put the CreateDDF.exe file in c:/CreateDDF
3) In your moss solution project in Visual Studio, right click on the project and choose 'Unload Project'

4) Once the project has been unloaded, right click it again, and choose 'Edit projectname.csproj'

5) Scroll all the way to the bottom of the .csproj file where you see the following code



6) Change the above code to:

<Target Name="BeforeBuild"> <Exec Command="$(MakeWSPPath) -n $(MSBuildProjectName)" /> </Target> <Target Name="AfterBuild"> <Exec Command="$(MakeCabPath) /F $(MSBuildProjectName).ddf /D CabinetNameTemplate=$(MSBuildProjectName).wsp /D DiskDirectory1=wsp" /> </Target> <PropertyGroup> <MakeWSPPath>"C:\CreateDDF\CreateDDF.exe"</MakeWSPPath> <MakeCabPath>"C:\Windows\System32\makecab.exe"</MakeCabPath> </PropertyGroup>

7) Save the file and reload the project (click yes if you see a popup message)

8) Build the project, and a directory named 'wsp' will be created along side the /bin directory. The wsp file will be in there.

Enjoy...

(Thanks to Andrew Connell for the tweaking of the .csproj tip. Got that part from the Telerik integration guide he did)

Update(9/23/07): I've created a Visual Studio 2005 project tempate for wsp development. Check it out!

Manifest.xml Entries Needed for Deploying Telerik ASP.Net Controls into MOSS

Mon, 13 Aug 2007 16:50:26 GMT

Recently, Andrew Connell published a white paper on the Telerik site explaining how to create WSP files for the Telerik ASP.Net controls. In the document, AC used the RadMenu control as his example, but I noticed that there was a couple of entries in the SafeControls block of the manifest.xml file that were specific to the RadMenu control. This made wonder if there were other controls that needed control-specific SafeControls entries, so I decided to take a look.

Most of the controls have a couple of different namespaces referenced, and the RadCalendar takes things a step further and references the RadInput control, which means that the RadInput.Net2.dll assembly needs to be packaged with it.

Andrew's document is awesome, but I wanted to post this as a supplement to answer potential questions around the manifest.xml file if you want to deploy any of the other RadControls into your MOSS farm.

Assuming that you already have the Telerik Editor for MOSS, I'm ignoring the entries needed for the RadSpell and the RadEditor controls, as they are shipped with it...

RadAjax

<Assembly DeploymentTarget="GlobalAssemblyCache" Location="RadAjax.Net2.dll"> <SafeControls>          <SafeControl Namespace="Telerik.RadAjaxPanelDesign" TypeName="*" Safe="True" />
         <SafeControl Namespace="Telerik.WebControls" TypeName="*" Safe="True" /> </SafeControls> <ClassResources>  </ClassResources> </Assembly>

RadCalendar

<Assemblies> <Assembly DeploymentTarget="GlobalAssemblyCache" Location="RadInput.Net2.dll"> <SafeControls> <SafeControl Namespace="Telerik.RadInputUtils" TypeName="*" Safe="True" /> <SafeControl Namespace="Telerik.WebControls" TypeName="*" Safe="True" /> </SafeControls> </Assembly> <Assembly DeploymentTarget="GlobalAssemblyCache" Location="RadCalendar.Net2.dll"> <SafeControls> <SafeControl Namespace="Telerik.RadCalendarUtils" TypeName="*" Safe="True" /> <SafeControl Namespace="Telerik.WebControls" TypeName="*" Safe="True" /> </SafeControls> <ClassResources>  </ClassResources> </Assembly> </Assemblies>

To conserve space here, I've made an xml file with all the manifest entries available for download.

*.csproj file replacement
Make sure the path to your MakeCab.exe file is correct, but to create the WSP on-build of the project, replace the following text in the csproj file

<Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" /> 

with

<PropertyGroup> <MakeCabPath>"C:\Windows\System32\makecab.exe"</MakeCabPath> </PropertyGroup> <Target Name="Build"> <Exec Command="$(MakeCabPath) /F TelerikSkins.ddf /D CabinetNameTemplate=$(MSBuildProjectName).wsp /D DiskDirectory1=wsp"/> </Target>

Download all Telerik manifest entries

Creating a WSS Solution to deploy custom publishing items

Mon, 23 Jul 2007 22:05:37 GMT

Most of the documentation I've seen out there around creating publishing items such as master pages and page layouts has developers using SharePoint Designer to create them. This is ok, but it only gets you so far, and I see problems with the approach when you require more robust development. Also, when it came to using SharePoint Designer, I always had the question - 'how do you develop a master page or page layout locally in development, and deploy it to a completely different farm?'

As my past couple of posts might point to, I've been working a lot with WSS Solutions lately, and I'm currently working with a client who's doing a migration from MCMS 2002 to MOSS. The solution is completely custom, and needs to be as robust as possible. Part of the project has been documenting the best possible configuration for MOSS CMS development, so I figured what I've found would be something good to share.

Essentially, there's two features in the solution. One feature for custom resource files (RESX) and another feature for all the custom publishing items. I'm using the full Telerik Editor for MOSS - which seems to have all the kinks worked out from the earlier versions - along with some other Telerik ASP.NET controls. I've heard that Andrew Connell is working with Telerik on releasing a whitepaper at the end of this month that will provide the needed guidance for leveraging best practices in implementing all of the Telerik ASP.NET components into MOSS and WSS v3, and I'll most likely touch on it in the future, as well.

I don't want to really cover the details of the MOSS resource feature in this post, but Mikhail Dikov has a great one on creating custom resource files in MOSS, so make sure to check it out. I will, however, give you what you need to get it up and running.

So - let's start from scratch!

Create a new Class Library project in Visual Studio 2005:

Once it's created, delete Class1.cs.

Add a reference to Windows SharePoint Services, Microsoft Content Publishing and Management, and System.Web.

I really like to mirror the installation directory on the server, so I normally set up a folder structure in my projects to match what the file structure on the server looks like, along with the folders that correspond with the locations of the files I'm going to add..

The first thing I'm going to do is create the resource feature along with the needed feature receivers to deploy the resource files to the App_GlobalResources directory of the web application it's installed on.

This is code I mainly obtained from Mikhail's post, but here's how you set up the resource feature:

If you set up the folder structure just like I did in the image above, create a class in the 'Objects' directory called DeployCustomResourceJob.cs, with the following code:

using System; using System.Collections.Generic; using System.Text; using Microsoft.SharePoint.Administration; using Microsoft.SharePoint.Utilities; using System.Diagnostics; using System.IO; namespace MOSSFeatures.Objects { public class DeployCustomResourcesJob : SPJobDefinition { #region Fields [Persisted] private string _SourcePath; private string _SomethignElse; #endregion #region Constructors public DeployCustomResourcesJob() : base() { } public DeployCustomResourcesJob(string jobName, SPWebApplication webApp, string featureName) : base(jobName, webApp, null, SPJobLockType.Job) { //get the path to the feature directory this._SourcePath = SPUtility.GetGenericSetupPath("Template"); //uncomment the following line (commented to fix a bug in livewriter) // + "\\FEATURES\\" + featureName; } #endregion #region Job Handling public override void Execute(Guid targetInstanceId) { try { //get the web application for the current job - I'm pretty sure this is the same as calling 'base.WebApplication' SPWebApplication webApp = this.Parent as SPWebApplication; foreach (SPUrlZone zone in webApp.IisSettings.Keys) { //the settings of the IIS application to update SPIisSettings settings = webApp.IisSettings[zone]; //determine the destination path string destPath = Path.Combine(settings.Path.ToString(), "App_GlobalResources"); //get the RESX files from the feature directory string[] filePaths = Directory.GetFiles(this._SourcePath, "*.resx"); //copy/overwrite the RESX files into the App_GlobalResource directory foreach (string filePath in filePaths) { string fileName = Path.GetFileName(filePath);//get the filename of the file to copy File.Copy(filePath, Path.Combine(destPath, fileName), true);//copy it over the file in the Resource directory } } } catch (Exception ex) { Debug.WriteLine("Failed to copy global resource"); Debug.WriteLine(ex); throw; } } #endregion } }

Next - create a class in the 'FeatureReceivers' directory called CustomFeatureReceiver.cs. This is the feature receiver which will move the resource files once the feature is activated. Here's the code:

using System; using System.Collections.Generic; using System.Text; using Microsoft.SharePoint; using Microsoft.SharePoint.Administration; using MOSSFeatures.Objects; namespace MOSSFeatures.FeatureReceivers { public class CustomResourceReceiver : SPFeatureReceiver { #region Constants const string JOB_TITLE = "Deploy Custom Resources"; const string JOB_NAME = "job-deploy-custom-resources"; #endregion #region Events public override void FeatureActivated(SPFeatureReceiverProperties properties) { SPWeb web = properties.Feature.Parent as SPWeb; //check for an exisiting instance of the job - if we find it, delete it foreach (SPJobDefinition job in web.Site.WebApplication.JobDefinitions) { if (job.Name == JOB_NAME && job.WebApplication.Name == web.Site.WebApplication.Name) { job.Delete(); string something = "nothing"; } } //create a new deployment job DeployCustomResourcesJob deployJob = new DeployCustomResourcesJob(JOB_NAME,
               web.Site.WebApplication,
               properties.Definition.DisplayName); deployJob.Title = JOB_TITLE; deployJob.Schedule = new SPOneTimeSchedule(DateTime.Now); deployJob.Update(); } public override void FeatureDeactivating(SPFeatureReceiverProperties properties) { SPWeb web = properties.Feature.Parent as SPWeb; //delete the job, if there is one foreach (SPJobDefinition job in web.Site.WebApplication.JobDefinitions) { if (job.Name == JOB_NAME && job.WebApplication.Name ==
                  web.Site.WebApplication.Name) { job.Delete(); } } //we could delete the resource files here if we want to } public override void FeatureInstalled(SPFeatureReceiverProperties properties) { //throw new Exception("The method or operation is not implemented."); } public override void FeatureUninstalling(SPFeatureReceiverProperties properties) { //throw new Exception("The method or operation is not implemented."); } #endregion } }

Create two RESX files in the TEMPLATE\FEATURES\CustomResources project directory - CustomResources.en-US.resx, and CustomResources.resx. According to Mikhail, one resource file is used during the provisioning process, and the other is used at run-time, but the rule I use is that the entries in both resource files should match. These two files will contains contain the resource strings used in the custom publishing feature, as well as anywhere else you might need them.

Create the Feature.xml file for the CustomResources feature.

<Feature Title="CustomResourceFeature" Id="AC3CB30C-905F-433f-A635-DA13291BCC08" Description="Deploys localization resources used for MOSSFeatures to the App_GlobalResources directory" Version="1.0.0.0" Scope="Site" xmlns="http://schemas.microsoft.com/sharepoint/" ReceiverAssembly="MOSSFeatures, Version=1.0.0.0, Culture=neutral, PublicKeyToken=ENTER_YOUR_PUBLIC_KEY_HERE" ReceiverClass="MOSSFeatures.FeatureReceivers.CustomResourceReceiver" AlwaysForceInstall="true" ActivateOnDefault="false"> <ElementManifests> <ElementFile Location="CustomResources.en-US.resx"/> <ElementFile Location="CustomResources.resx"/> </ElementManifests> </Feature>

There - that's all you need to implement custom resource files in MOSS. Now we need to create the WSS Solution file (WSP) to deploy them.

At the root of the project, create a new file called CreateMOSSFeatures_WSP.ddf. This ddf file is used by makecab so it knows where to place files inside the cabinet (WSP) file.

Enter the following code in the ddf file

.OPTION EXPLICIT ;generate errors .Set CabinetNameTemplate=MOSSFeatures.wsp .Set DiskDirectoryTemplate=CDROM ;All cabinets go into a single directory .Set CompressionType=MSZIP ;** All files are compressed in cabinet files .Set UniqueFiles="ON" .Set Cabinet=on .Set DiskDirectory1= ;Here's the way it works... ;FileToCopyFromInProject NewFileInCABFile ;manifest file manifest.xml manifest.xml ;assemblies bin\debug\MOSSFeatures.dll MOSSFeatures.dll ;features ;FeatureName\feature.xml FeatureName\feature.xml ;FeatureName\elements.xml FeatureName\elements.xml ;CustomResources TEMPLATE\FEATURES\CustomResources\Feature.xml CustomResources\Feature.xml TEMPLATE\FEATURES\CustomResources\CustomResources.en-US.resx CustomResources\CustomResources.en-US.resx TEMPLATE\FEATURES\CustomResources\CustomResources.resx CustomResources\CustomResources.resx

TEMPLATE\FEATURES\CustomResources\CustomResources.en-US.resx RESOURCES\CustomResources.en-US.resx
TEMPLATE\FEATURES\CustomResources\CustomResources.resx RESOURCES\CustomResources.resx

Now, we need to create the manifest file for the WSS Solution. The manifest file will tell the solution receiver in the MOSS farm where to put the files located inside the WSP cabinet once the solution is installed.  It will also tell the receiver to place the assembly into the GAC, and deploy the code across all servers in the farm.

At the root of the project file, create a file named manifest.xml with the following code:

<?xml version="1.0" encoding="utf-8" ?> <Solution SolutionId="ENTER_SOLUTION_ID_GUID_HERE" xmlns="http://schemas.microsoft.com/sharepoint/" ResetWebServer="TRUE"> <Assemblies> <Assembly DeploymentTarget="GlobalAssemblyCache" Location="MOSSFeatures.dll"> <SafeControls> <SafeControl Safe="True" Assembly="MOSSFeatures, Version=1.0.0.0, Culture=neutral,
                     PublicKeyToken=ENTER_YOUR_PUBLIC_KEY_HERE"
                     Namespace="MOSSFeatures" TypeName="*"/> </SafeControls> </Assembly> </Assemblies> <Resources> <Resource Location="CustomResources\CustomResources.en-US.resx"/> <Resource Location="CustomResources\CustomResources.resx"/> </Resources> <FeatureManifests> <FeatureManifest Location="CustomResources\Feature.xml"/> </FeatureManifests> <RootFiles> <RootFile Location="Resources\CustomResources.en-US.resx"/> <RootFile Location="Resources\CustomResources.resx"/> </RootFiles> </Solution>

Now that we have the ddf and the manifest files created, we can set up a post-build event in Visual Studio that will run makecab and create the WSP file for us. To add the post build event, right-click on the project in the Visual Studio Solution Explorer and choose 'Properties'

Enter the following lines in the Post-build event command line text box:

cd $(ProjectDir)
makecab /f CreateMOSSFeatures_WSP.ddf

We also need to make sure that we sign the assembly, so when the solution is deployed, it can be added to the GAC.

For ease in deployment, as I stated in a previous post, it's a good idea to create some command files to handle the solution deployment, update, and removal. Now's a good time to add the directory which contains stsadm to the Path Windows System Variable if you haven't done it already, and doing so will allow you to run stsadm from any directory. To set this up, right-click on My Computer, and choose Properties. On the Advanced tab, click the Environment Variables button, and append ';C:\Program Files\Common Files\Microsoft Shared\web server extensions\12\BIN' to the end of the Path variable.

Now, you can create the cmd files and refer to stsadm inside them. There's three files: Deploy.cmd, Update.cmd, and Remove.cmd, rather than explain what's going on in theme in exhausting detail, here's the code:

Deploy.cmd

@ECHO OFF SET SITE_URL="http://mossdevelopment.richfinn.net" SET SOLUTION_NAME=MOSSFeatures.wsp REM ----- Deactivate the feature(s) ----- stsadm -o deactivatefeature -name CustomResources -url %SITE_URL% -force REM ----- Remove the features and solution ----- stsadm -o retractsolution -name %SOLUTION_NAME% -immediate -url %SITE_URL% ECHO . ECHO . ECHO ------------------------------------------------------------------------------------------- ECHO Verify that the correct solutions have been completly retracted and then press ENTER ECHO ------------------------------------------------------------------------------------------- ECHO . pause ECHO ON REM ----- Delete the solution ----- stsadm -o deletesolution -name %SOLUTION_NAME% REM ----- Add and depoly the solution ----- stsadm -o addsolution -filename %SOLUTION_NAME% stsadm -o deploysolution -n %SOLUTION_NAME% -immediate -allowgacdeployment -allowCasPolicies -url %SITE_URL% ECHO OFF ECHO . ECHO . ECHO ------------------------------------------------------------------------------------------- ECHO Solution deployment complete, press ENTER to activate features, if any ECHO ------------------------------------------------------------------------------------------- pause ECHO ON REM ----- Active features ----- stsadm -o activatefeature -name CustomResources -url %SITE_URL% -force REM ----- Remove the following comment if features are present REM pause

Update.cmd

cls ECHO OFF SET SITE_URL="http://mossdevelopment.richfinn.net" SET SOLUTION_NAME=MOSSFeatures.wsp REM ECHO . REM ECHO . REM ECHO ------------------------------------------------------------------------------------------- REM ECHO Verify that the correct solutions have been completly retracted and then press ENTER REM ECHO ------------------------------------------------------------------------------------------- REM ECHO . pause ECHO ON stsadm -o upgradesolution -name %SOLUTION_NAME% -filename %SOLUTION_NAME% -immediate -allowgacdeployment ECHO OFF ECHO . ECHO . ECHO ------------------------------------------------------------------------------------------- ECHO Solution deployment complete, press ENTER to activate features, if any ECHO ------------------------------------------------------------------------------------------- pause ECHO ON REM ----- Active features ----- stsadm -o activatefeature -name CustomResources -url %SITE_URL% -force pause

Remove.cmd

ECHO OFF SET SITE_URL="http://mossdevelopment.richfinn.net" SET SOLUTION_NAME=MOSSFeatures.wsp REM ----------- Remove the features ------------------ stsadm -o deactivatefeature -name CustomResources -url %SITE_URL% -force REM ----------- Retract the solution ---------------- stsadm -o retractsolution -name %SOLUTION_NAME% -immediate -url %SITE_URL% pause REM ----------- Execute Time Jobs -------------------- REM stsadm execadmsvcjobs REM ----------- Delete the solution ----------------- stsadm -o deletesolution -name %SOLUTION_NAME% pause

*** IMPORTANT ***

Finally, here's a tricky part. You need to manually add your assembly to the <assemblies> block of each web.config file in your farm, or the code will bomb. Should track in the schema like this:

<configuration> <system.web> <compilation batch="false" debug="false"> <assemblies> <add assembly="MOSSFeatures, Version=1.0.0.0, Culture=neutral, PublicKeyToken=YOUR_PUBLIC_KEY"/> </assemblies> </compilation> </system.web> </configuration>

OK! Now that the resources are out there, we can create the custom publishing feature using the resources just like you see in the out-of-box publishing layouts feature that came with MOSS. Creating this feature is kind of a long process, but it really explains solution development in MOSS being that it has so many different components. I feel that if you can get this, you can really do anything in the platform.

When it comes to web content publishing, there's three primary things needed, a content type, a master page, and a page layout. The content type defines the different columns - or in MCMS lingo 'content placeholders' - and custom meta-data which will be used in the page layouts (content templates) you'll have in your publishing site. The master page is the frame of the page - usually the top and left sides of the page - and is the container for the page layouts. Finally, the page layouts contains the physical content placeholders where the content editors enter their text, images, links, etc...

Just like with page layout development in SharePoint Designer, the first thing we need is the content type. Content types are defined by columns, so we set the columns up first in a file at the root FEATURES\CustomPublishingLayouts called CustomPublishingColumns.xml. I want to keep this example simple and clean, so I'm only going to create a single column for content. Here's the code:

<Elements xmlns="http://schemas.microsoft.com/sharepoint/"> <Field ID="ENTER_CUSTOM_GUID_HERE" Name="content"
         Group="$Resources:CustomResources,ColumnGroup_CustomPublishingColumns_Title;"
DisplayName="$Resources:CustomResources,column_content_displayname;" Type="HTML"
         Required="FALSE" Sealed="TRUE" RichText="TRUE" RichTextMode="FullHtml"></Field> </Elements>

You can see how I'm referencing the entries in the custom resource files created previously. (The entries are already in the resource files in the downloadable code)

Now that we've got the content placeholder column created, we can create the content type. In the same directory as CustomPublishingColumns.xml, create another xml file called CustomPublishingContentType.xml with the following code:

  <Elements xmlns="http://schemas.microsoft.com/sharepoint/"> <ContentType ID="0x01010007FF3E057FA8AB4AA42FCB67B453FFC100E214EEE741181F4E9F7ACC43278EE811002D7E961EBCD042C6A40B97F107579F70"
         Group="$Resources:cmscore,group_pagelayoutcontenttypes;"
         Name="$Resources:CustomResources,ContentTypes_CustomPublishingContentType_Title;"
         Description="$Resources:CustomResources,ContentTypes_CustomPublishingContentType_Description;"> <FieldRefs> <FieldRef ID="ENTER_SAME_GUID_AS_COLUMN" Name="$Resources:CustomResources,column_content_displayname;"/> </FieldRefs> <DocumentTemplate TargetName="/_layouts/CreatePage.aspx" /> </ContentType> </Elements>

You can see the custom content type ID here. Chris O'Brian has a nice post on deploying content types as features along with how to create a custom content type ID. Long story short, a custom content type id is created by taking the content type id of the content type you're inheriting from, adding two zeros, and then adding a new guid with no dashes or brackets.

Now, we need to create the master page. Heather Solomon has a great blank master page which I like using as a starting place for my master page development. Make sure you download it, or you can just get it from the solution I've uploaded (link's at the bottom of this post)

Add two new folders to the CustomPublishingLayouts feature - MasterPages, and PageLayouts.

In the MasterPages directory, create two files named blank.master, and blank.master.cs. Yes, that's right, code behind for the master page - something you don't get in Designer. One thing you'll notice is that you don't get the greatest visual studio support for the files, so they appear side-by-side rahter than in the nice hierarchy you see in a custom asp.net web application project.

Another thing - make sure you don't use the CodeBehind attribute in the page directive of the ASPX page. Note sure why, but it doesn't compile if it's there. Just use the Inherits attribute and you'll be fine...

blank.master (from Heather Solomon)

<%@Master language="C#" AutoEventWireup="true" Inherits="MOSSFeatures.MasterPages.blank"%> <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <%@ Register Tagprefix="SharePoint" Namespace="Microsoft.SharePoint.WebControls" Assembly="Microsoft.SharePoint, Version=12.0.0.0,

Culture=neutral, PublicKeyToken=71e9bce111e9429c" %>

<%@ Register Tagprefix="Utilities" Namespace="Microsoft.SharePoint.Utilities" Assembly="Microsoft.SharePoint, Version=12.0.0.0,

Culture=neutral, PublicKeyToken=71e9bce111e9429c" %>

<%@ Import Namespace="Microsoft.SharePoint" %> <%@ Import Namespace="Microsoft.SharePoint.ApplicationPages" %> <%@ Register Tagprefix="WebPartPages" Namespace="Microsoft.SharePoint.WebPartPages"
Assembly="Microsoft.SharePoint, Version=12.0.0.0,

Culture=neutral, PublicKeyToken=71e9bce111e9429c" %> <%@ Register TagPrefix="wssuc" TagName="Welcome" src="~/_controltemplates/Welcome.ascx"
%> <%@ Register TagPrefix="wssuc" TagName="DesignModeConsole" src="~/_controltemplates/DesignModeConsole.ascx"

%> <HTML id="HTML1" dir="<%$Resources:wss,multipages_direction_dir_value%>" runat="server"
   xmlns:o="urn:schemas-microsoft-com:office:office"

__expr-val-dir="ltr"> <HEAD id="HEAD1" runat="server"> <META Name="GENERATOR" Content="Microsoft SharePoint"> <META Name="progid" Content="SharePoint.WebPartPage.Document"> <META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=utf-8"> <META HTTP-EQUIV="Expires" content="0"> <SharePoint:RobotsMetaTag ID="RobotsMetaTag1" runat="server"/> <Title ID=onetidTitle><asp:ContentPlaceHolder id=PlaceHolderPageTitle runat="server"/></Title> <SharePoint:Theme ID="Theme1" runat="server"/> <SharePoint:ScriptLink ID="ScriptLink1" language="javascript" name="core.js" Defer="true" runat="server"/> <SharePoint:CustomJSUrl ID="CustomJSUrl1" runat="server"/> <SharePoint:SoapDiscoveryLink ID="SoapDiscoveryLink1" runat="server"/> <SharePoint:CssLink ID="CssLink1" runat="server"/> <style type="text/css"> /**** Overriding styles for branding ~ located in the CSSSTyleLibrary ****/ @import url(/CSSStyleLibrary/name.css); </style> <asp:ContentPlaceHolder id="PlaceHolderAdditionalPageHead" runat="server"/> <SharePoint:DelegateControl ID="DelegateControl1" runat="server" ControlId="AdditionalPageHead" AllowMultipleControls="true"/> </HEAD> <BODY scroll="yes" onload="javascript:if (typeof(_spBodyOnLoadWrapper) != 'undefined') _spBodyOnLoadWrapper();"> <form id="Form1" runat="server" onsubmit="return _spFormOnSubmitWrapper();"> <WebPartPages:SPWebPartManager id="m" runat="Server"/>  <asp:ContentPlaceHolder id="PlaceHolderGlobalNavigation" runat="server"> <span id="TurnOnAccessibility" style="display:none"> <a href="#" class="ms-skip" onclick="SetIsAccessibilityFeatureEnabled(true);UpdateAccessibilityUI();return false;"> <SharePoint:EncodedLiteral ID="EncodedLiteral1" runat="server" text="<%$Resources:wss,master_turnonaccessibility%>"

EncodeMethod="HtmlEncode"/></a> </span> <A id="A1" href="javascript:;" onclick="javascript:this.href='#mainContent';" class="ms-skip"

AccessKey="<%$Resources:wss,maincontent_accesskey%>" runat="server"> <SharePoint:EncodedLiteral ID="EncodedLiteral2" runat="server" text="<%$Resources:wss,mainContentLink%>"
      EncodeMethod="HtmlEncode"/></A> <span id="TurnOffAccessibility" style="display:none"> <a href="#" class="ms-acclink" onclick="SetIsAccessibilityFeatureEnabled(false);UpdateAccessibilityUI();return false;"> <SharePoint:EncodedLiteral ID="EncodedLiteral3" runat="server" text="<%$Resources:wss,master_turnoffaccessibility%>"

EncodeMethod="HtmlEncode"/></a> </span>  <asp:ContentPlaceHolder id="PlaceHolderGlobalNavigationSiteMap" runat="server"> <asp:SiteMapPath SiteMapProvider="SPSiteMapProvider" id="GlobalNavigationSiteMap"

RenderCurrentNodeAsLink="true" SkipLinkText="" NodeStyle-CssClass="ms-sitemapdirectional" runat="server"/> </asp:ContentPlaceHolder>  <SharePoint:DelegateControl ID="DelegateControl2" runat="server" ControlId="GlobalSiteLink0"/> <wssuc:Welcome id="IdWelcome" runat="server" EnableViewState="false"> </wssuc:Welcome> <SharePoint:DelegateControl ID="DelegateControl3" ControlId="GlobalSiteLink1" Scope="Farm" runat="server"/> <SharePoint:DelegateControl ID="DelegateControl4" ControlId="GlobalSiteLink2" Scope="Farm" runat="server"/> <a href="javascript:TopHelpButtonClick('NavBarHelpHome')" AccessKey="<%$Resources:wss,multipages_helplink_accesskey%>"

id="TopHelpLink" title="<%$Resources:wss,multipages_helplinkalt_text%>" runat="server">

<img id="Img1" align='absmiddle' border=0 src="/_layouts/images/helpicon.gif" alt="<%$Resources:wss,multipages_helplinkalt_text%>"
   runat="server"></a> </asp:ContentPlaceHolder>   <SharePoint:SiteLogoImage id="onetidHeadbnnr0" LogoImageUrl="/_layouts/images/titlegraphic.gif" runat="server"/> <asp:ContentPlaceHolder id="PlaceHolderSiteName" runat="server"> <SharePoint:SPLinkButton runat="server" NavigateUrl="~site/" id="onetidProjectPropertyTitle"> <SharePoint:ProjectProperty ID="ProjectProperty1" Property="Title" runat="server" /> </SharePoint:SPLinkButton> </asp:ContentPlaceHolder>   <asp:ContentPlaceHolder id="PlaceHolderSearchArea" runat="server"> <SharePoint:DelegateControl ID="DelegateControl5" runat="server" ControlId="SmallSearchInputBox"/> </asp:ContentPlaceHolder>   <asp:ContentPlaceHolder id="PlaceHolderTopNavBar" runat="server"> <asp:ContentPlaceHolder id="PlaceHolderHorizontalNav" runat="server"> <SharePoint:AspMenu ID="TopNavigationMenu" Runat="server" DataSourceID="topSiteMap" EnableViewState="false" AccessKey="<%$Resources:wss,navigation_accesskey%>" Orientation="Horizontal" StaticDisplayLevels="2" MaximumDynamicDisplayLevels="1" DynamicHorizontalOffset="0" StaticPopoutImageUrl="/_layouts/images/menudark.gif" StaticPopoutImageTextFormatString="" DynamicHoverStyle-BackColor="#CBE3F0" SkipLinkText="" StaticSubMenuIndent="0" CssClass="ms-topNavContainer"> <StaticMenuStyle/> <StaticMenuItemStyle CssClass="ms-topnav" ItemSpacing="0px"/> <StaticSelectedStyle CssClass="ms-topnavselected" /> <StaticHoverStyle CssClass="ms-topNavHover" /> <DynamicMenuStyle BackColor="#F2F3F4" BorderColor="#A7B4CE" BorderWidth="1px"/> <DynamicMenuItemStyle CssClass="ms-topNavFlyOuts"/> <DynamicHoverStyle CssClass="ms-topNavFlyOutsHover"/> <DynamicSelectedStyle CssClass="ms-topNavFlyOutsSelected"/> </SharePoint:AspMenu> <SharePoint:DelegateControl ID="DelegateControl6" runat="server" ControlId="TopNavigationDataSource"> <Template_Controls> <asp:SiteMapDataSource ShowStartingNode="False" SiteMapProvider="SPNavigationProvider" id="topSiteMap" runat="server" StartingNodeUrl="sid:1002"/> </Template_Controls> </SharePoint:DelegateControl> </asp:ContentPlaceHolder>  <SharePoint:SiteActions runat="server" AccessKey="<%$Resources:wss,tb_SiteActions_AK%>" id="SiteActionsMenuMain" PrefixHtml="<div><div>" SuffixHtml="</div></div>" MenuNotVisibleHtml="&nbsp;"> <CustomTemplate> <SharePoint:FeatureMenuTemplate ID="FeatureMenuTemplate1" runat="server" FeatureScope="Site" Location="Microsoft.SharePoint.StandardMenu" GroupId="SiteActions" UseShortId="true" > <SharePoint:MenuItemTemplate runat="server" id="MenuItem_Create" Text="<%$Resources:wss,viewlsts_pagetitle_create%>" Description="<%$Resources:wss,siteactions_createdescription%>" ImageUrl="/_layouts/images/Actionscreate.gif" MenuGroupId="100" Sequence="100" UseShortId="true" ClientOnClickNavigateUrl="~site/_layouts/create.aspx" PermissionsString="ManageLists, ManageSubwebs" PermissionMode="Any" /> <SharePoint:MenuItemTemplate runat="server" id="MenuItem_EditPage" Text="<%$Resources:wss,siteactions_editpage%>" Description="<%$Resources:wss,siteactions_editpagedescription%>" ImageUrl="/_layouts/images/ActionsEditPage.gif" MenuGroupId="100" Sequence="200" ClientOnClickNavigateUrl="javascript:MSOLayout_ChangeLayoutMode(false);" /> <SharePoint:MenuItemTemplate runat="server" id="MenuItem_Settings" Text="<%$Resources:wss,settings_pagetitle%>" Description="<%$Resources:wss,siteactions_sitesettingsdescription%>" ImageUrl="/_layouts/images/ActionsSettings.gif" MenuGroupId="100" Sequence="300" UseShortId="true" ClientOnClickNavigateUrl="~site/_layouts/settings.aspx" PermissionsString="EnumeratePermissions,ManageWeb,ManageSubwebs,
               AddAndCustomizePages,ApplyThemeAndBorder,ManageAlerts,ManageLists,ViewUsageData" PermissionMode="Any" /> </SharePoint:FeatureMenuTemplate> </CustomTemplate> </SharePoint:SiteActions> </asp:ContentPlaceHolder>   <asp:ContentPlaceHolder ID="WSSDesignConsole" runat="server"> <wssuc:DesignModeConsole id="IdDesignModeConsole" runat="server"/> </asp:ContentPlaceHolder> <asp:ContentPlaceHolder ID="SPNavigation" runat="server"> <SharePoint:DelegateControl ID="DelegateControl7" runat="server" ControlId="PublishingConsole" PrefixHtml="<tr><td colspan="4" id="mpdmconsole" class="ms-consolemptablerow">" SuffixHtml="</td></tr>"> </SharePoint:DelegateControl> </asp:ContentPlaceHolder>   <asp:ContentPlaceHolder id="PlaceHolderPageImage" runat="server"/> <asp:ContentPlaceHolder id="PlaceHolderTitleLeftBorder" runat="server"/>  <asp:ContentPlaceHolder id="PlaceHolderTitleBreadcrumb" runat="server"> <asp:SiteMapPath SiteMapProvider="SPContentMapProvider" id="ContentMap" SkipLinkText=""

NodeStyle-CssClass="ms-sitemapdirectional" runat="server"/>   </asp:ContentPlaceHolder>  <table> <tr> <td height=100% valign=top ID=onetidPageTitle class="ms-pagetitle"> <h2 class="ms-pagetitle"> <asp:ContentPlaceHolder id="PlaceHolderPageTitleInTitleArea" runat="server" /> </h2> </td> </tr> </table>  <asp:ContentPlaceHolder id="PlaceHolderMiniConsole" runat="server"/> <asp:ContentPlaceHolder id="PlaceHolderTitleRightMargin" runat="server"/> <asp:ContentPlaceHolder id="PlaceHolderTitleAreaSeparator" runat="server"/>   <asp:ContentPlaceHolder id="PlaceHolderLeftNavBarDataSource" runat="server" />  <asp:ContentPlaceHolder id="PlaceHolderCalendarNavigator" runat="server" /> <asp:ContentPlaceHolder id="PlaceHolderLeftNavBarTop" runat="server"/>  <asp:ContentPlaceHolder id="PlaceHolderLeftNavBar" runat="server">  <label class="ms-hidden"><SharePoint:EncodedLiteral ID="EncodedLiteral4" runat="server"

text="<%$Resources:wss,quiklnch_pagetitle%>" EncodeMethod="HtmlEncode"/></label> <Sharepoint:SPSecurityTrimmedControl ID="SPSecurityTrimmedControl1" runat="server" PermissionsString="ViewFormPages"> <SharePoint:SPLinkButton id="idNavLinkViewAll" runat="server" NavigateUrl="~site/_layouts/viewlsts.aspx"

Text="<%$Resources:wss,quiklnch_allcontent%>" AccessKey="<%$Resources:wss,quiklnch_allcontent_AK%>"/></div> </SharePoint:SPSecurityTrimmedControl>  <Sharepoint:SPNavigationManager id="QuickLaunchNavigationManager" runat="server" QuickLaunchControlId="QuickLaunchMenu" ContainedControl="QuickLaunch" EnableViewState="false"> <SharePoint:DelegateControl ID="DelegateControl8" runat="server" ControlId="QuickLaunchDataSource"> <Template_Controls> <asp:SiteMapDataSource SiteMapProvider="SPNavigationProvider" ShowStartingNode="False" id="QuickLaunchSiteMap" StartingNodeUrl="sid:1025" runat="server" /> </Template_Controls> </SharePoint:DelegateControl> <SharePoint:AspMenu id="QuickLaunchMenu" DataSourceId="QuickLaunchSiteMap" runat="server" Orientation="Vertical" StaticDisplayLevels="2" ItemWrap="true" MaximumDynamicDisplayLevels="0" StaticSubMenuIndent="0" SkipLinkText="" > <LevelMenuItemStyles> <asp:MenuItemStyle CssClass="ms-navheader"/> <asp:MenuItemStyle CssClass="ms-navitem"/> </LevelMenuItemStyles> <LevelSubMenuStyles> <asp:SubMenuStyle CssClass="ms-navSubMenu1"/> <asp:SubMenuStyle CssClass="ms-navSubMenu2"/> </LevelSubMenuStyles> <LevelSelectedStyles> <asp:MenuItemStyle CssClass="ms-selectednavheader"/> <asp:MenuItemStyle CssClass="ms-selectednav"/> </LevelSelectedStyles> </SharePoint:AspMenu> </Sharepoint:SPNavigationManager>  <Sharepoint:SPNavigationManager id="TreeViewNavigationManager" runat="server" ContainedControl="TreeView"> <SharePoint:SPLinkButton runat="server" NavigateUrl="~site/_layouts/viewlsts.aspx" id="idNavLinkSiteHierarchy"

Text="<%$Resources:wss,treeview_header%>" AccessKey="<%$Resources:wss,quiklnch_allcontent_AK%>"/> <SharePoint:SPHierarchyDataSourceControl runat="server" id="TreeViewDataSource" RootContextObject="Web" IncludeDiscussionFolders="true" /> <SharePoint:SPRememberScroll runat="server" id="TreeViewRememberScroll"
         onscroll="javascript:_spRecordScrollPositions(this);" Style="overflow: auto;height: 400px;width: 150px; "> <Sharepoint:SPTreeView id="WebTreeView" runat="server" ShowLines="false" DataSourceId="TreeViewDataSource" ExpandDepth="0" SelectedNodeStyle-CssClass="ms-tvselected" NodeStyle-CssClass="ms-navitem" NodeStyle-HorizontalPadding="2" SkipLinkText="" NodeIndent="12" ExpandImageUrl="/_layouts/images/tvplus.gif" CollapseImageUrl="/_layouts/images/tvminus.gif" NoExpandImageUrl="/_layouts/images/tvblank.gif" > </Sharepoint:SPTreeView> </Sharepoint:SPRememberScroll> </Sharepoint:SPNavigationManager>  <SharePoint:SPLinkButton runat="server" NavigateUrl="~site/_layouts/recyclebin.aspx"

id="idNavLinkRecycleBin" ImageUrl="/_layouts/images/recycbin.gif"

Text="<%$Resources:wss,StsDefault_RecycleBin%>" PermissionsString="DeleteListItems"/> </asp:ContentPlaceHolder>  <asp:ContentPlaceHolder id="PlaceHolderLeftActions" runat="server"/> <asp:ContentPlaceHolder id="PlaceHolderNavSpacer" runat="server"><IMG SRC="/_layouts/images/blank.gif"

width=138 height=1 alt=""></asp:ContentPlaceholder> <asp:ContentPlaceHolder id="PlaceHolderLeftNavBarBorder" runat="server"></asp:ContentPlaceHolder> <asp:ContentPlaceHolder id="PlaceHolderBodyLeftBorder" runat="server"/>  <PlaceHolder id="MSO_ContentDiv" runat="server"> <table id="MSO_ContentTable" width=100% height="100%" border="0" cellspacing="0" cellpadding="0"
      class="ms-propertysheet"> <tr> <td class='ms-bodyareaframe' valign="top" height="100%"> <A name="mainContent"></A> <asp:ContentPlaceHolder id="PlaceHolderPageDescription" runat="server"/> <asp:ContentPlaceHolder id="PlaceHolderMain" runat="server"> </asp:ContentPlaceHolder> </td> </tr> </table> </PlaceHolder>  <asp:ContentPlaceHolder id="PlaceHolderBodyRightMargin" runat="server"/> <asp:ContentPlaceHolder id="PlaceHolderFormDigest" runat="server"> <SharePoint:FormDigest ID="FormDigest1" runat=server/> </asp:ContentPlaceHolder> <input type="text" name="__spDummyText1" style="display:none;" size=1/> <input type="text" name="__spDummyText2" style="display:none;" size=1/> </form> <asp:ContentPlaceHolder id="PlaceHolderUtilityContent" runat="server"/> <asp:ContentPlaceHolder id="PlaceHolderBodyAreaClass" runat="server"/> <asp:ContentPlaceHolder id="PlaceHolderTitleAreaClass" runat="server"/>  <asp:Panel ID="Panel1" visible="false" runat="server">  </asp:Panel>  </BODY> </HTML>

blank.master.cs

using System; using System.Data; using System.Configuration; using System.Collections; using System.Web; using System.Web.Security; using System.Web.UI; using System.Web.UI.WebControls; using System.Web.UI.WebControls.WebParts; using System.Web.UI.HtmlControls; namespace MOSSFeatures.MasterPages { public class blank : System.Web.UI.MasterPage { protected void Page_Load(object sender, EventArgs e) { } } }

Now for the Page Layout, create two files in PageLayouts named customPageLayout.aspx and customPageLayout.aspx.cs

customPageLayout.aspx

<%@ Page Language="C#" Inherits="MOSSFeatures.PageLayouts.customPageLayout" meta:progid="SharePoint.WebPartPage.Document" %> <%@ Register Tagprefix="SharePointWebControls" Namespace="Microsoft.SharePoint.WebControls" Assembly="Microsoft.SharePoint,
Version=12.0.0.0,

Culture=neutral, PublicKeyToken=71e9bce111e9429c" %>

<%@ Register Tagprefix="WebPartPages" Namespace="Microsoft.SharePoint.WebPartPages" Assembly="Microsoft.SharePoint,
Version=12.0.0.0,

Culture=neutral, PublicKeyToken=71e9bce111e9429c" %>

<%@ Register Tagprefix="PublishingWebControls" Namespace="Microsoft.SharePoint.Publishing.WebControls"
Assembly="Microsoft.SharePoint.Publishing, Version=12.0.0.0,

Culture=neutral, PublicKeyToken=71e9bce111e9429c" %>

<%@ Register Tagprefix="PublishingNavigation" Namespace="Microsoft.SharePoint.Publishing.Navigation"
Assembly="Microsoft.SharePoint.Publishing, Version=12.0.0.0,

Culture=neutral, PublicKeyToken=71e9bce111e9429c" %> <%@ Register TagPrefix="radE" Namespace="Telerik.SharePoint.FieldEditor"
Assembly="RadEditorSharePoint,Version=4.1.0.0,Culture=neutral,PublicKeyToken=1f131a624888eeed"%> <asp:Content ContentPlaceholderID="PlaceHolderPageTitle" runat="server"> <SharePointWebControls:FieldValue id="PageTitle" FieldName="Title" runat="server"/> </asp:Content> <asp:Content ContentPlaceholderID="PlaceHolderMain" runat="server"> <br/> <radE:RadHtmlField runat="server" id="content" FieldName="content"></radE:RadHtmlField> </asp:Content>

If you're not using the Telerik editor, you can use the out-of-box rich-text editor, but the Telerik editor is free - use it! I'm also assuming you've got it installed with this solution...

customPageLayout.aspx.cs

using System; using System.Collections.Generic; using System.Text; using Microsoft.SharePoint.Publishing; using System.Web.UI.WebControls; namespace MOSSFeatures.PageLayouts { public class customPageLayout : PublishingLayoutPage { protected void Page_Load(object sender, EventArgs e) { } } }

Now that we've got the master page and page layout, we need to provision it to the master page gallery on the server when the feature is activated. This is accomplished by using a provisioning module.

In the same directory as the content type and column definition files, create another xml file named ProvisionedFiles.xml

ProvisionedFiles.xml

<Elements xmlns="http://schemas.microsoft.com/sharepoint/"> <Module Name="CustomPageLayouts" RootWebOnly="TRUE" Path="PageLayouts" Url="_catalogs/masterpage"> <File Url="customPageLayout.aspx" Type="GhostableInLibrary" IgnoreIfAlreadyExists="false"> <Property Name="Title" Value="$Resources:CustomResources,PageLayouts_handbookHome_Title;"/> <Property Name="ContentType" Value="$Resources:cmscore,contenttype_pagelayout_name;"/> <Property Name="PublishingAssociatedContentType"

Value=";#$Resources:CustomResources,ContentTypes_CustomPublishingContentType_Title;;

#0x01010007FF3E057FA8AB4AA42FCB67B453FFC100E214EEE741181F4E9F7ACC43278EE811002D7E961EBCD042C6A40B97F107579F70;#"/> </File> </Module> <Module Name="CustomMasterPages" Url="_catalogs/masterpage" Path="MasterPages" RootWebOnly="TRUE"> <File Url="blank.master" Type="GhostableInLibrary"> <Property Name="ContentType" Value="$Resources:cmscore,contenttype_masterpage_name;" /> <Property Name="PublishingPreviewImage"

Value="~SiteCollection/_catalogs/masterpage/$Resources:core,Culture;/Preview Images/BlueBand.png,

~SiteCollection/_catalogs/masterpage/$Resources:core,Culture;/Preview Images/BlueBand.png" /> <Property Name="MasterPageDescription" Value="a blank master page used for testing purposes" /> </File> </Module> </Elements>

So - that's it for the basic elements needed for the custom publishing items. Now we just need the Feature.xml file for the publishing items. Create it in the root of the feature next to the content type and column definition files.

Feature.xml

<Feature xmlns="http://schemas.microsoft.com/sharepoint/" Title="Custom Publishing Feature" Scope="Site" Id="ENTER_NEW_GUID" AlwaysForceInstall="true" ActivateOnDefault="false" Version="1.0.0.0"> <ElementManifests> <ElementManifest Location="CustomPublishingColumns.xml"/> <ElementManifest Location="CustomPublishingContentType.xml"/> <ElementManifest Location="ProvisionedFiles.xml"/> </ElementManifests> </Feature>

Now, we need to update the ddf, manifest, and Deploy/Update/Remove cmd files for the solution deployment

The ddf file should now look like this:

.OPTION EXPLICIT ;generate errors .Set CabinetNameTemplate=MOSSFeatures.wsp .Set DiskDirectoryTemplate=CDROM ;All cabinets go into a single directory .Set CompressionType=MSZIP ;** All files are compressed in cabinet files .Set UniqueFiles="ON" .Set Cabinet=on .Set DiskDirectory1= ;Here's the way it works... ;FileToCopyFromInProject NewFileInCABFile ;manifest file manifest.xml manifest.xml ;assemblies bin\debug\MOSSFeatures.dll MOSSFeatures.dll ;features ;FeatureName\feature.xml FeatureName\feature.xml ;FeatureName\elements.xml FeatureName\elements.xml ;CustomResources TEMPLATE\FEATURES\CustomResources\Feature.xml CustomResources\Feature.xml TEMPLATE\FEATURES\CustomResources\CustomResources.en-US.resx CustomResources\CustomResources.en-US.resx TEMPLATE\FEATURES\CustomResources\CustomResources.resx CustomResources\CustomResources.resx TEMPLATE\FEATURES\CustomResources\CustomResources.en-US.resx RESOURCES\CustomResources.en-US.resx TEMPLATE\FEATURES\CustomResources\CustomResources.resx RESOURCES\CustomResources.resx ;CustomPublishingLayouts TEMPLATE\FEATURES\CustomPublishingLayouts\Feature.xml CustomPublishingLayouts\Feature.xml TEMPLATE\FEATURES\CustomPublishingLayouts\ProvisionedFiles.xml CustomPublishingLayouts\ProvisionedFiles.xml TEMPLATE\FEATURES\CustomPublishingLayouts\CustomPublishingColumns.xml CustomPublishingLayouts\CustomPublishingColumns.xml TEMPLATE\FEATURES\CustomPublishingLayouts\CustomPublishingContentType.xml CustomPublishingLayouts\CustomPublishingContentType.xml ;Publishing Layouts Page Layouts TEMPLATE\FEATURES\CustomPublishingLayouts\PageLayouts\customPageLayout.aspx
   FEATURES\CustomPublishingLayouts\PageLayouts\customPageLayout.aspx ;Publishing Layouts Master Pages TEMPLATE\FEATURES\CustomPublishingLayouts\MasterPages\blank.master FEATURES\CustomPublishingLayouts\MasterPages\blank.master

Here's the updated manifest.xml file:

<?xml version="1.0" encoding="utf-8" ?> <Solution SolutionId="ENTER_SOLUTION_ID_GUID_HERE" xmlns="http://schemas.microsoft.com/sharepoint/" ResetWebServer="TRUE"> <Assemblies> <Assembly DeploymentTarget="GlobalAssemblyCache" Location="MOSSFeatures.dll"> <SafeControls> <SafeControl Safe="True" Assembly="MOSSFeatures, Version=1.0.0.0, Culture=neutral,

PublicKeyToken=ENTER_YOUR_PUBLIC_KEY_HERE" Namespace="MOSSFeatures" TypeName="*"/> </SafeControls> </Assembly> </Assemblies> <Resources> <Resource Location="CustomResources\CustomResources.en-US.resx"/> <Resource Location="CustomResources\CustomResources.resx"/> </Resources> <FeatureManifests> <FeatureManifest Location="CustomResources\Feature.xml"/> <FeatureManifest Location="CustomPublishingLayouts\Feature.xml"/> </FeatureManifests> <TemplateFiles>  <TemplateFile Location="FEATURES\CustomPublishingLayouts\PageLayouts\customPageLayout.aspx"/>  <TemplateFile Location="FEATURES\CustomPublishingLayouts\MasterPages\blank.master"/> </TemplateFiles> <RootFiles> <RootFile Location="Resources\CustomResources.en-US.resx"/> <RootFile Location="Resources\CustomResources.resx"/> </RootFiles> </Solution>

Deploy.cmd

@ECHO OFF SET SITE_URL="http://mossdevelopment.richfinn.net" SET SOLUTION_NAME=MOSSFeatures.wsp REM ----- Deactivate the feature(s) ----- stsadm -o deactivatefeature -name CustomResources -url %SITE_URL% -force stsadm -o deactivatefeature -name CustomPublishingLayouts -url %SITE_URL% -force REM ----- Remove the features and solution ----- stsadm -o retractsolution -name %SOLUTION_NAME% -immediate -url %SITE_URL% ECHO . ECHO . ECHO ------------------------------------------------------------------------------------------- ECHO Verify that the correct solutions have been completly retracted and then press ENTER ECHO ------------------------------------------------------------------------------------------- ECHO . pause ECHO ON REM ----- Delete the solution ----- stsadm -o deletesolution -name %SOLUTION_NAME% REM ----- Add and depoly the solution ----- stsadm -o addsolution -filename %SOLUTION_NAME% stsadm -o deploysolution -n %SOLUTION_NAME% -immediate -allowgacdeployment -allowCasPolicies -url %SITE_URL% ECHO OFF ECHO . ECHO . ECHO ------------------------------------------------------------------------------------------- ECHO Solution deployment complete, press ENTER to activate features, if any ECHO ------------------------------------------------------------------------------------------- pause ECHO ON REM ----- Active features ----- stsadm -o activatefeature -name CustomResources -url %SITE_URL% -force stsadm -o activatefeature -name CustomPublishingLayouts -url %SITE_URL% -force REM ----- Remove the following comment if features are present REM pause

Update.cmd

cls ECHO OFF SET SITE_URL="http://mossdevelopment.richfinn.net" SET SOLUTION_NAME=MOSSFeatures.wsp REM ECHO . REM ECHO . REM ECHO ------------------------------------------------------------------------------------------- REM ECHO Verify that the correct solutions have been completly retracted and then press ENTER REM ECHO ------------------------------------------------------------------------------------------- REM ECHO . pause ECHO ON stsadm -o upgradesolution -name %SOLUTION_NAME% -filename %SOLUTION_NAME% -immediate -allowgacdeployment ECHO OFF ECHO . ECHO . ECHO ------------------------------------------------------------------------------------------- ECHO Solution deployment complete, press ENTER to activate features, if any ECHO ------------------------------------------------------------------------------------------- pause ECHO ON REM ----- Active features ----- stsadm -o activatefeature -name CustomResources -url %SITE_URL% -force stsadm -o activatefeature -name CustomPublishingLayouts -url %SITE_URL% -force pause

Remove.cmd

ECHO OFF SET SITE_URL="http://mossdevelopment.richfinn.net" SET SOLUTION_NAME=MOSSFeatures.wsp REM ----------- Remove the features ------------------ stsadm -o deactivatefeature -name CustomResources -url %SITE_URL% -force stsadm -o deactivatefeature -name CustomPublishingLayouts -url %SITE_URL% -force REM ----------- Retract the solution ---------------- stsadm -o retractsolution -name %SOLUTION_NAME% -immediate -url %SITE_URL% pause REM ----------- Execute Time Jobs -------------------- REM stsadm execadmsvcjobs REM ----------- Delete the solution ----------------- stsadm -o deletesolution -name %SOLUTION_NAME% pause

Now, deploying the solution will provision the new master page, page layout, and content type. Pages can now be created using the new layouts, as well. When you need to update the page layouts, just run the Update.cmd file, and the solution will be updated with the changes.

This was a fairly basic solution for deploying custom publishing items, but you can see how powerful and extensible it is, and leveraging resource files is pretty cool, too. Next I hope to show how you can create a custom site definition to provision sites using the custom page layouts rather than the out of box page layout.

Here's the source project for this solution: MOSSFeatures_CustomPublishingFeature.zip

Application to generate lines for DDF, Manifest, and Provisioning Files

Fri, 20 Jul 2007 16:02:00 GMT

I've recently come to the conclusion that when creating a wss solution (WSP), writing the needed lines for the ddf, manifest and provisioning files can be really time consuming. This is especially painful when it comes to images that are needed in master pages and page layout files, as the number of images can be quite large sometimes. So, I've created a little console app that creates the lines automatically and outputs them to a text file. All you need to do manually is copy and paste them into the correct files in the solution.

The output looks like this:

****************************************************** *************** MASTERPAGE *************** ****************************************************** ***** DDF ***** TEMPLATE\FEATURES\CustomPublishingLayouts\MasterPages\blank.master FEATURES\CustomPublishingLayouts\MasterPages\blank.master TEMPLATE\FEATURES\CustomPublishingLayouts\MasterPages\client1.master FEATURES\CustomPublishingLayouts\MasterPages\client1.master ***** MANIFEST ***** <TemplateFile Location="FEATURES\ClientPublishingLayouts\MasterPages\blank.master"/> <TemplateFile Location="FEATURES\ClientPublishingLayouts\MasterPages\client1.master"/> ***** PROVISION ***** <File Url="blank.master" Type="GhostableInLibrary"/> <File Url="client1.master" Type="GhostableInLibrary"/> ******************************************************

The program is currently set up to create the needed lines in the case of a custom publishing feature, but it can be easily changed for any feature type.

There's a configuration file which allows you to enter the directories and templates for output. Looks like this:

<?xml version="1.0" encoding="utf-8" ?> <Templates> <Template Name="ClientPublishingLayouts MasterPages"
         Path="C:\Development\Solution\Project\TEMPLATE\FEATURES\ClientPublishingLayouts\MasterPages"> <Item Name="DDF"
         Text="TEMPLATE\FEATURES\ClientPublishingLayouts\MasterPages\FILENAME
         FEATURES\ClientPublishingLayouts\MasterPages\FILENAME"/> <Item Name="MANIFEST"
         Text="<TemplateFile Location="
         FEATURES\ClientPublishingLayouts\MasterPages\FILENAME"/>"/> <Item Name="PROVISION"
         Text="<File Url="FILENAME"
         Type="GhostableInLibrary"/>"/> </Template> <Template Name="_Layouts\ClientPages\Migration"
         Path="C:\Development\Solution\Project\TEMPLATE\LAYOUTS\ClientPages\Migration"> <Item Name="DDF"
         Text="TEMPLATE\LAYOUTS\ClientPages\Migration\FILENAME
         LAYOUTS\ClientPages\Migration\FILENAME"/> <Item Name="MANIFEST"
         Text="<TemplateFile Location="
         LAYOUTS\ClientPages\Migration\FILENAME"/>"/> </Template> etc... </Templates>

You can download the source here: CreateEntriesInSolutionFiles.zip

So if you downloaded this before 7/23, the current download is a new release. Uses only one configuration file, and cleaner code...

Deploying SharePoint Solutions (WSP) containing features that use feature receivers

Tue, 10 Jul 2007 20:50:38 GMT

I was trying to create a feature that used a custom feature receiver which was called when the feature was activated and I was following all of the different examples and samples and blogs that were out there, but I kept getting this error:

Failed to create feature receiver object from assembly "AssemblyName, Version=1.0.0.0, Culture=neutral, PublicKeyToken=KEY", type "AssemblyName.ClassName" for feature GUID: System.ArgumentNullException: Value cannot be null.
Parameter name: type
at System.Activator.CreateInstance(Type type, Boolean nonPublic)
at System.Activator.CreateInstance(Type type)
at Microsoft.SharePoint.Administration.SPFeatureDefinition.get_ReceiverObject()

no idea what this was at all, but I think I did find what fixed it!

In the <Feature> element of my Feature.xml file, I took out the SolutionID attribute, and then I added AlwaysForceInstall="true" and ActivateOnDefault="false". To get the feature to activate on install, call stsadm -o activatefeature in the bat file you use to install the solution...

Update (8/31/2007):
Figured a little more out about this. One potential issue is that the fully qualified class name might not be correct. In MOSS development, we often change the namespace of a class to be different than the one Visual Studio gives it when the class file is created. Make sure the feature receiver class name matches the one in the class file...

Creating MOSS Solutions (WSP Files)

Mon, 02 Jul 2007 20:50:38 GMT

One of the greatest development features in MOSS is the ability to create solution files which can be managed and deployed across your development landscape as you moved towards production.  When a solution is deployed, all files inside are deployed to the correct locations, which is extremely helpful in a load balanced environment.

I'll demonstrate here what it takes to get a solution up and running from scratch. This is the template I use for all my new WSP files.
Create a class library project in Visual Studio. I'll name mine 'SampleWSSSolution'. Once the project has loaded, right click on the project name in the project explorer, and click 'Properties'. On the 'Signing' tab, click the checkbox 'Sign the assembly' and in the drop down choose '<new>'. In the 'Create Strong Name Key' popup, enter 'SampleWSSSolution' in the 'Key file name:' text box, and uncheck the 'Protect my key file with a password' checkbox.
In the same project properties screen, click the 'Build Events' tab, and enter the following into the 'Post-build event command line:' text area:

cd $(ProjectDir)
makecab /f CreateSolutionCAB.ddf

This code will create the WSP file in the root directory of the project.

Now, create four files in the VS project:
- CreateSolutionCAB.ddf
- manifest.xml
- Deploy.cmd
- Upgrade.cmd
Here's what the contents of the files should look like:

CreateSolutionCAB.ddf
This file tells makecab.exe what files to put into the CAB file
-----------------------------------------------------------------------

.OPTION EXPLICIT ;generate errors .Set CabinetNameTemplate=SOLUTIONNAME.wsp .Set DiskDirectoryTemplate=CDROM ;All cabinets go into a single directory .Set CompressionType=MSZIP ;** All files are compressed in cabinet files .Set UniqueFiles="ON" .Set Cabinet=on .Set DiskDirectory1= ;Here's the way it works... ;FileToCopyFromInProject NewFileInCABFile ;manifest file manifest.xml manifest.xml ;features FeatureName\feature.xml FeatureName\feature.xml FeatureName\elements.xml FeatureName\elements.xml ;aspx pages CustomPageDirectoryName/default.aspx LAYOUTS\CustomPageDirectoryName\default.aspx FeatureName\FeaturePageName.aspx LAYTOUS\DirectoryName\FeaturePageName.aspx ;web parts WebPartDirectoryName\feature.xml WebPartDirectryNameInFEATURES\feature.xml WebPartDirectoryName\elementmanifest.xml WebPartDirectryNameInFEATURES\elementmanifest.xml WebPartDirectoryName\WebPartName.webpart WebPartDirectryNameInFEATURES\WebPartName.webpart ;assemblies bin\debug\SampleWSSSolution.dll SampleWSSSolution.dll

----------------------------------------------------------------------------------------------------------------------------

manifest.xml
This file is the manifest of the solution and tells WSS the contents and where to put them once it is deployed
----------------------------------------------------

<Solution SolutionId="GUID" xmlns=http://schemas.microsoft.com/sharepoint/
ResetWebServer="TRUE"> <FeatureManifests> <FeatureManifest Location="WebPartDirectryNameInFEATURES\feature.xml"/> <FeatureManifest Location="FeatureName\feature.xml"/> </FeatureManifests> <TemplateFiles> <TemplateFile Location="LAYOUTS\CustomPageDirectoryName\default.aspx"/> <TemplateFile Location="LAYTOUS\DirectoryName\FeaturePageName.aspx"/> </TemplateFiles> <Assemblies> <Assembly DeploymentTarget="GlobalAssemblyCache" Location="SampleWSSSolution.dll"> <SafeControls> <SafeControl Assembly="SampleWSSSolution, Version=1.0.0.0, Culture=Neutral,
PublicKeyToken=assembyPublicKeyToken"
                  Namespace="SampleWSSSolution" TypeName="*"/> </SafeControls> </Assembly> </Assemblies> </Solution>

-------------------------------------------------------------------------------------------------------

Deploy.cmd
----------------------------------------------------

REM ----- Deactivate the feature(s) ----- stsadm -o deactivatefeature -name FEATURENAME -url "http://www.sitecollectionurl.com" -force REM ----- Remove the features and solution ----- stsadm -o retractsolution -name SampleWSSSolution.wsp -immediate -url
"http://www.sitecollectionurl.com" ECHO OFF ECHO . ECHO . ECHO ------------------------------------------------------------------------------------------- ECHO Verify that the correct solutions have been completly retracted and then press ENTER ECHO ------------------------------------------------------------------------------------------- ECHO . pause ECHO ON REM ----- Delete the solution ----- stsadm -o deletesolution -name SampleWSSSolution.wsp REM ----- Add and depoly the solution ----- stsadm -addsolution -filename SampleWSSSolution.wsp stsadm -deploysolution -n SampleWSSSolution.wsp
   -immediate -allowgacdeployment
   -url "http://www.sitecollectionurl.com" ECHO OFF ECHO . ECHO . ECHO ------------------------------------------------------------------------------------------- ECHO Solution deployment complete, press ENTER to activate features, if any ECHO ------------------------------------------------------------------------------------------- pause ECHO ON REM ----- Active features ----- stsadm -o activatefeature -name FEATURENAME -url "http://www.sitecollectionurl.com" -force REM ----- Remove the following comment if features are present REM pause

----------------------------------------------------------------------------------------------------------------------

Upgrade.cmd
-------------------------------------------------

cls REM ----- Deactivate the feature(s) ----- stsadm -o deactivatefeature -name FEATURENAME -url "http://www.sitecollectionurl.com" -force ECHO OFF ECHO . ECHO . ECHO ------------------------------------------------------------------------------------------- ECHO Verify that the correct solutions have been completly retracted and then press ENTER ECHO ------------------------------------------------------------------------------------------- ECHO . pause ECHO ON REM ----- Upgrade the solution ----- stsadm -upgradesolution -n SOLUTIONNAME.wsp
   -filename SOLUTIONNAME.wsp
   -immediate -allowgacdeployment
   -url "http://www.sitecollectionurl.com" ECHO OFF ECHO . ECHO . ECHO ------------------------------------------------------------------------------------------- ECHO Solution deployment complete, press ENTER to activate features, if any ECHO ------------------------------------------------------------------------------------------- pause ECHO ON REM ----- Active features ----- stsadm -o activatefeature -name FEATURENAME -url "http://www.sitecollectionurl.com" -force REM ----- Remove the following comment if features are present REM pause

----------------------------------------------------------------------------------------------------------------------------

If you have features in the solution, make sure you add the following line to the <assemblies> section of the web.config of your web application
<add assembly="SampleWSSSolution, Version=1.0.0.0, Culture=neutral, PublicKeyToken=assemblyPublicKeyToken" />
Now you can create features, web parts, web services, etc. Just make sure you change the placeholder content in the different files to the correct names of the features you create. Once you're finished creating the solution, run the Deploy.cmd file and the solution will be added to the Solution Management section of the Operations tab in Central Admin

So, when do you use Deploy.cmd and when do you use Upgrade.cmd?

Use deploy for the first deployment of the solution, or for local development deployments where you need to deactivate the features as well as remove the solution for a clean install. Upgrade will run -upgradesolution which updates deployed files, such as the assembly and aspx files. This works great for re-deploying Page Layout files that are already being used in production. I'll most likely post on the Publishing deployment process soon...