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!

Recently, I've seen a bunch of announcements about new public-facing Internet sites being released out into the wild running on SharePoint.  This is awesome because it's great to see people catching on to the web content management features in the product.  I do need get something off my chest, though...

If you've got a public facing SharePoint site that allows anonymous access, ACTIVATE THE ViewFormPagesLockDown FEATURE!!!!!!!

This is especially true if you've spent any amount of time customizing the branding of your site.

Sezai has a good post on the Feature, and the TechNet documentation provides the details.

ViewFormsPagesLockDown is a MOSS-only Feature (not in WSS) that does a couple things:

1) Allows users to only view the Publishing pages in your site, not any of the form or view pages (DispForm.aspx, AllItems.aspx)
2) Disallows anonymous access to pages in the _layouts directory that inherit from LayoutsPageBase.

This Feature is active on the Publishing Portal site definition by default, but NOT on the Collaboration Portal site definition.

Without this Feature active on anonymous public sites, any and all users - including search engines like Live and Google - will be able to view (and crawl) SharePoint out-of-box pages which are tied to lists and webs that allow viewing by anonymous users.  These users might not have the ability to do anything, but it most likely will not be what your organization would prefer of them to view.  In some cases, you might not care, but keep reading...

If you want to see some interesting and scary stats on how many sites there are that have NOT got the ViewFormPagesLockDown Feature activated, check out this result-set from Live Search.  Currently Live Search is returning 29,200 results, some being duplicates from the same site, but they are all links to sites that have the Publishing Feature installed, allow anonymous access, and have not activated the LockDown Feature.  It's also a great result set to see some public-facing SharePoint, but that's not the point.

This is an easy fix! Activate the Feature! Please rest assured, though, that if this Feature is not active, and your site security is configured correctly, anonymous users should not be able to do anything in your site.

One thing to note for you MOSS devs out there, I found that the lock-down on _layouts was a bit of a problem because I sometimes like to put custom application pages in the _layouts directory which I want to be hit by anonymous users.  To get around the lock-down, there's the UnsecuredLayoutsPageBase class you can use as the base class of your page, and there's always just the Page class as in a standard ASP.Net application page.

We've been working on this one for a while, and it's been driving us nuts...

In the current project we're working on, we haven't been able to add any new web parts to pages, nor have we been able to edit the properties on the existing ones.  When we do, we've been seeing the three following errors:

- Cannot save the property settings for this Web Part. Exception occurred. (Exception from HRESULT: 0x80020009 (DISP_E_EXCEPTION))
- Unable to add selected web part(s). Exception occurred. (Exception from HRESULT: 0x80020009 (DISP_E_EXCEPTION))
- Unable to add selected web part(s). List View Web Part could not be added, list may be hidden.

Even stranger was that it was only occurring in the root web of the current site collection.

In researching the 0x80020008 error when related to web parts, the few people that have found anything have said that it could be caused by disposal of the SPContext.Current.Site or SPContect.Current.Web objects.  We looked all over our code and didn't find that we were doing that anywhere.

We switched the master page back to the default.master, and we could add and edit web parts without any issues, so we then started whittling down the server controls on the custom master page until we found three custom server controls that were present when the web part errors occur.  Taking a closer look, these three controls all had the following lines in common.

            using (SPWeb
rootWeb = SPContext.Current.Site.RootWeb) { //code }

Commenting out of the code caused the errors to go away.  What's going on here? 

Turns out that there's something that the Best Practices: Using Disposable Windows SharePoint Services Objects post and Roger Lamb's SharePoint 2007 and WSS 3.0 Dispose Patterns by Example should point out a little clearer.  If you look at the bottom of Roger's post, there's a comment by Stephen Kaye where he hits the nail on the head:

If your current context’s web is the root web of you current context’s site then the RootWeb property of the site will reference the same object return by SPControl.GetContextWeb and SPContext.Current.Web and should therefore not be disposed.

So, this means that if you are in the root web of your site collection, and you dispose of SPContext.Current.Site.RootWeb, you're actually disposing of SPContext.Current.Web.  Not good.

Here's how we changed the code to ensure that we could use the RootWeb SPWeb object, but not dispose it if the SPContext.Current.Web is the RootWeb:

SPWeb rootWeb = null; if (SPContext.Current.Web.IsRootWeb)
rootWeb = SPContext.Current.Web; else rootWeb
= SPContext.Current.Site.RootWeb; //codeif (!SPContext.Current.Web.IsRootWeb)
rootWeb.Dispose();

So, earlier I posted how I upgraded WSSv3 to MOSS.

After I completed that task, I wanted to see what it would take to turn my existing top level site collection into a publishing site, as the Publishing Feature is one of the lowest hanging fruit in the MOSS Feature stack that has the greatest benefit to both users and administrators right out of the gates.

The first thing we need to do is enable the Office SharePoint Server Publishing Infrastructure feature in the site collection features list.

Uh oh:

The logs say that access was denied activating the Publishing Resources feature and the message is 'Provisioning did not succeed. Details: Failed to provision the scheduling job definitions.  Page scheduling will not succeed.'  Then there are some other messages in the logs that say that an exception was thrown ensuring dependencies were met for the Publishing Site Feature.

According to a post I found on NetAdminTools.com, you can activate the Publishing Resources via stsadm, then click the Activate button in the site collection Features list.  This seemed to work pretty well:

Then I activated the Office SharePoint Server Publishing Feature in the Site Features list (in the Site Administration group) and the Pages list was created and the site actions menu was expanded, and there was much rejoicing (yaaay)

BUT WAIT!

When I created a new page, something seemed off.  There were only a few pages available in the 'choose page layout' list box.  Looks like some article pages and welcome pages were missing.  I went to the mast page gallery and saw that there weren't any pages missing, but there were some pages, like the welcome page with web part zones page layout - which is the page layout used on the default page of the Collaboration Portal site definition - that were not associated to their proper Content Types! Uh - Weird!  How did this happen, and how can we fix it?

Creating new site collections based on the Team Site template proved that we could activate the Publishing Infrastructure Feature without the access denied error, but the page layouts still didn't have the Content Type associated in the Master Page Gallery. Tried this on four site collections.  PublishingPrerequisites, PublishingResources, Navigation, and PublishingLayouts are the Feature Activation Dependencies on the PublishingSite Feature (the Publishing Infrastructure Feature name) and they are all scoped to the site, so why are the page layouts not getting associated with the Content Types?

Creating a new site collection based on the Collaboration Portal site definition worked fine, and the page layouts were associated correctly. Lame.  Must be the order that the site Features are activated.

After going through the Features listed in the onet.xml file for the Collaboration Portal site definition in the order defined, order's NOT the problem.  What is you ask?

So - turns out that the page layouts are tagged as being part of the Master Page Content Type - what's up with that?!?
 

Eidt the page and change the Content Type to the correct one (Page Layout), then set the Associated Content Type.

Check In, Publish a Major Version, and Approve it. Fixed!

Bug...

This seems to have come up a lot for me lately: We have a client who wants to know what it takes to upgrade from WSSv3 to MOSS. What do they need to do to make the MOSS Features available in their current WSS sites?

Having been primarily only working with MOSS, I haven't done much with just WSS and have never run through the upgrade process to MOSS.  There was very little documentation out there other than some forum posts, so today I ran through it for the heck of it and was impressed, but unsurprised, that it was pretty smooth.

To begin, I installed the slipstreamed WSS+SP1 available from Microsoft downloads onto a fresh Windows Server 2003 virtual.  I set it up using SQL 2005 instead of SQL Express, which was a little lazy on my part, because I should have run through what it would take to move the SQL Express stuff over to SQL 2005. Oh well.

I set up my web application with a site collection at the root based on the standard Team Site definition.  This site then got two sub sites.  All three sites had a single Word document in it's Shared Documents doc library.

Then, I installed MOSS+SP1 from MSDN Subscriber Downloads. Here's the steps with some screen shots that I thought were of value:

1) Ran install of MOSS.  Pretty straightforward.  Extracted files, entered key, selected server type, installation of bits and securing of resources, etc, etc...

2) Ran configuration wizard. Says 'This wizard will upgrade SharePoint Products and Technologies'. Config wizard is aware of config db. Runs through nine tasks without hanging on anything for too long, and then completes.

3) Opened Central Admin. On the Operations tab:

When clicked:

Check and click OK:

Completed pretty quick:


One thing to note here - this just enabled the Enterprise SKU Features, I think because I entered an Enterprise key from MSDN, so none of the Standard Features were activated. FYI...

4) Started new services:

5) Created SSP - nothing special here

6) To get Search lined up, I created a Search Center site at the root of the site collection, and changed the site collection search settings to use the new search center I just created:

That was pretty much it. Like I said, impressed, but not surprised.

In our current SharePoint project, we have a custom site definition based on the out-of-box Publishing Site with Workflow. We found a little problem with this though, because when the out-of-box Features for Publishing and it's Parallel Approval workflow are activated, the default SharePoint Approvers group is the only group that is set to approve a publishing page that has been sent into the workflow. The problem is, we want to inherit the parent site's workflow settings - otherwise known as the association data - because our application has 'channels' of content that each has a different group who can approve the content in their appropriate channel.

The group that can approve publishing pages in each channel is defined in the root web of the channel by doing nothing more than editing the Parallel Approval workflow on the Pages list, and then setting the correct group on the People Picker for the workflow approvers property. Since channel owners can create new sites in their channel using our custom provisioning process, we don't want them to have to go into the Pages list workflow settings to set the correct group every time, because as we all know, people make mistakes. Why not automate this process and set the right approvers group for the channel owner when the new site is created?

To do this, we created a Feature that we included in our custom site definition.  When a new site is created and the Feature is activated, we execute the following code:

            

              using System; using System.Collections.Generic; using System.Text; using Microsoft.SharePoint; using System.Diagnostics; using Microsoft.SharePoint.Workflow; using System.Xml; using Microsoft.SharePoint.Publishing; namespace Demo
{ publicclass FeatureReceiver
: SPFeatureReceiver { publicoverridevoid FeatureActivated(SPFeatureReceiverProperties
properties) { //get the SPWeb object for the Feature's
scope SPWeb currentWeb = properties.Feature.Parent as SPWeb; //set
the AllowUnsafeUpdates property to true so we can apply the change to the workflow currentWeb.AllowUnsafeUpdates
= true; //get the
parent web of the current web - this is where the correct workflow settings are SPWeb
parentWeb = currentWeb.ParentWeb; //get the Pages list
from the current web using the PublishingWeb object SPList currentWebPublishingList
= PublishingWeb.GetPublishingWeb(currentWeb).PagesList; //get
the current web Pages list's workflows SPWorkflowAssociationCollection currentWebWorkflows
= currentWebPublishingList.WorkflowAssociations; //if
the site has workflows, we need to get the parent web's workflow and apply the same
approvers to itif (currentWebWorkflows.Count
>= 1) { //find the parallel approval workflow SPWorkflowAssociation
currentWorkflowAssociation = currentWebWorkflows.GetAssociationByName("Parallel
Approval", currentWeb.Locale); //empty container
for the parent pages list workflow SPWorkflowAssociation parentWorkflowAssociation
= null; //get the
parent site's pages list SPList parentPagesList = PublishingWeb.GetPublishingWeb(parentWeb).PagesList; //if
there's workflows attached, we need to find the Parallel Approval workflowif (parentPagesList.WorkflowAssociations.Count
> 0) { parentWorkflowAssociation = parentPagesList.WorkflowAssociations.GetAssociationByName("Parallel
Approval", parentWeb.Locale); } //if we have the
parent workflow, we need to copy the review settings to the childif (parentWorkflowAssociation
!= null) { //xmldoc
for the parent association data XmlDocument parentAssociationData = new XmlDocument();
parentAssociationData.LoadXml(parentWorkflowAssociation.AssociationData); //xmldoc
for the child workflow association data XmlDocument currentAssociationData
= new XmlDocument(); currentAssociationData.LoadXml(currentWorkflowAssociation.AssociationData); //we
need to create a namespace manager object because the xml data we want is //namespaced
with 'xmlns:my="http://schemas.microsoft.com/office/infopath/2003/myXSD"'//the
following code was obtained from John Wood's blog//url:
http://www.dotnetjunkies.com/WebLog/johnwood/archive/2005/08/25/132153.aspx//this
code will add all namespaces in the xml to the namespace manager, allowing us to correctly//create
XPath queries to retrive the data we need XmlNamespaceManager nsmgr = new XmlNamespaceManager(parentAssociationData.NameTable); foreach (XmlAttribute
attr in parentAssociationData.SelectSingleNode("/*").Attributes)
{ if (attr.Prefix == "xmlns")
nsmgr.AddNamespace(attr.LocalName, attr.Value); } //get
the Reviewers node from the parent workflow XmlNode parentReviewers = parentAssociationData.SelectSingleNode("//my:Reviewers",
nsmgr); //get the Reviewers node from the child workflow XmlNode
currentReviewers = currentAssociationData.SelectSingleNode("//my:Reviewers",
nsmgr); //set the Reviewer node of the child workflow
to be the same as the parent currentReviewers.InnerXml = parentReviewers.InnerXml; //update
the child workflow's association data currentWorkflowAssociation.AssociationData
= currentAssociationData.OuterXml; //update the child
workflow association in the database currentWebPublishingList.UpdateWorkflowAssociation(currentWorkflowAssociation);
} } //make sure you dispose of the parentWeb object parentWeb.Dispose();
} publicoverridevoid FeatureDeactivating(SPFeatureReceiverProperties
properties) { } publicoverridevoid FeatureInstalled(SPFeatureReceiverProperties
properties) { } publicoverridevoid FeatureUninstalling(SPFeatureReceiverProperties
properties) { } } } 

          

I just updated the Ajaxify MOSS codeplex release to include the needed web.config entries for using the .Net 3.5 version of System.Web.Extensions.

There is, however, one manual step you still have to perform to the web.config files in order to get this to work right. You still need to add the dependentAssembly elements to the configuration/runtime/assemblyBinding element, as shown below:
 

I tried a whole bunch of different ways to get the xpath in the SPWebConfigModification object to try and get it to work, but I think the problem is that it's either too ambiguous because there's no unique identifier available on the dependentAssembly element, or the namespace on the assemblyBinding element is causing problems.

All the other entries are being applied correctly, though.  Also, I try and help out a little by outputting the nodes in the stsadm command output after the nodes are applied :) - see:

Just mark and copy the lines from there, and you're halfway there.

The command names are on the releases tab in the codeplex project.  If you're upgrading from the ASP.Net AJAX 1.0 framework, make sure you uninstall the config mods first, before you add the 3.5 config mods.

Final note: I hope to be adding the needed lines for SilverLight pretty soon.

A few days ago, I mentioned that we're trying to automate as much as possible in our new SharePoint based product, and I explained how we are creating custom search scopes in a Feature Receiver.

Another component we're automating is the creation of Crawl Rules for the search engine in the SSP the site collection is associated.

According to MSDN crawl rules are defined as follows:

Crawl rules provide you with the ability to set the behavior of the Enterprise Search index engine when you want to crawl content from a particular path. By using these rules, you can:

• Prevent content within a particular path from being crawled. 

• Indicate that a particular path that would otherwise be excluded from the crawl should be crawled.

Here's how we're creating the crawl rules in code using a similar Feature Receiver as before:

            using System; using System.Collections.Generic; using System.Text; using Microsoft.SharePoint; using Microsoft.Office.Server.Search.Administration; using System.Diagnostics; publicclass FeatureReceiver
: SPFeatureReceiver { SPSite currentSite = null; publicoverridevoid FeatureActivated(SPFeatureReceiverProperties
properties) { //Debugger.Launch();this.currentSite
= properties.Feature.Parent as SPSite; createCrawlRules();
} privatevoid createCrawlRules()
{ //get the site SSP's search server instance SearchContext
searchContext = SearchContext.GetContext(this.currentSite); //For
this example, I'll just show how to exclude the Explorer view of a list//Notice
how we're using wildcard characters to specify that every /Forms/WebFldr.aspx page//
will be excluded regaurdless of protocol or location in the site collectionstring crawlRule
= " *://*/Forms/WebFldr.aspx"; //get
the content source for the search server Content sspContent = new Content(searchContext); //check
to see if the crawl rule exists, and create it if it doesn'tif (!sspContent.CrawlRules.Exists(rule))
{ 

            

              //create the crawl rule, setting the type of crawl rule
and the crawl rule string CrawlRule crawlRule = sspContent.CrawlRules.Create(CrawlRuleType.ExclusionRule,
rule); //we want to make sure that the rule still works
if there are querystring variables crawlRule.FollowComplexUrls = true; //at
this point, you can set other properties such as authentication information to crawl//
content using a different identity or authentication method//
for more info , check out http://technet.microsoft.com/en-us/library/cc263150(TechNet.10).aspx//commit
the rule in the database crawlRule.Update(); } } 

            

              

                public
                override
                void FeatureDeactivating(SPFeatureReceiverProperties
properties){} 

              

                public
                override
                void FeatureInstalled(SPFeatureReceiverProperties
properties){} 

              

                public
                override
                void FeatureUninstalling(SPFeatureReceiverProperties
properties){} 

            
            

}

          

I've recently been working on a SharePoint project which is being offered to clients as a product built on top of the SharePoint framework.  While I can't describe in too much detail exactly what the product is, I figured it might be beneficial to discuss how we've built out certain aspects of the solution.  At the very least, I can compile some notes of my own so I can remember later how tackled some of the issues we had during the dev process.

To give a little background on the product, at the core, this is primarily a publishing-based solution that is deployed into a site collection. One of the goals in the development of the product has been to automate the creation of the site collection as much as possible when a new client purchases the product.  We're handling the bulk of the new client deployment through a Feature called 'Product.SiteConfiguration' that when activated, executes a Feature Receiver that both creates some higher-level components and populates 'default' data in areas of the site that are required for the product to function properly.

One of the things we're creating in the SiteConfiguration Feature Receiver is a locally defined, custom search scope that is specific to the site collection of the product. A search scope allows the narrowing of search results based on rules defined within the scope, so we wanted to create a scope that is specific to the product so that when a user searches from the product's generic search box, only items from within the product are returned.

Here's sample code used to create a new scope in a site collection:

            using System; using System.Collections.Generic; using System.Text; using Microsoft.SharePoint; using Microsoft.Office.Server.Search.Administration; using System.Diagnostics; namespace LocalDev.Demo.Code
{ publicclass SiteConfiguration
: SPFeatureReceiver { SPSite currentSite = null; publicoverridevoid FeatureActivated(SPFeatureReceiverProperties
properties) { string scopeName = "ProductScope"; this.currentSite
= properties.Feature.Parent as SPSite; //get
the site SSP's search server instance SearchContext searchContext = SearchContext.GetContext(this.currentSite); //get
the current scopes defined in the search server Scopes scopes = new Scopes(searchContext); //create
a URI object for the current site - used in checking for the scope we're creatingstring siteUrl
= this.currentSite.Url; Uri siteUri = new Uri(siteUrl); //create
scope object for the new scope Scope newScope = null; try { //this
is a little bit of a hack, but if it bombs, we know the scope doesn't exist newScope
= scopes.GetScope(siteUri, scopeName); } catch { //create
the new scope newScope = scopes.AllScopes.Create(scopeName, scopeName + "
Description", siteUri, true, "/_layouts/product/customsearchresults.aspx",
ScopeCompilationType.AlwaysCompile); //create the scopes
rules for the new scope//for example, include
content from the site newScope.Rules.CreateUrlRule(ScopeRuleFilterBehavior.Include,
UrlScopeRuleType.Folder, siteUrl); //save the changes
to the SSP Content Database scopes.Update(); //start
compilation of the scope scopes.StartCompilation(); } } publicoverridevoid FeatureDeactivating(SPFeatureReceiverProperties
properties) { } publicoverridevoid FeatureInstalled(SPFeatureReceiverProperties
properties) { } publicoverridevoid FeatureUninstalling(SPFeatureReceiverProperties
properties) { } } }

I've started getting tired of following the steps on Mike Ammerlaan's blog for Integrating ASP.NET AJAX with SharePoint.  It's not that the steps are difficult to follow, but there's a lot of stuff you need to get right if you want to have all the ASP.NET AJAX functionality available in MOSS.

To ease my own pains with this process - and hopefully yours, too - I've published to CodePlex some STSADM extensions for adding and removing the needed ASP.NET AJAX entries to the web.config file.

Much thanks to Gary Lapointe for providing the source code for his STSADM extensions.  It served as a great starting place for me and decreased the ramp-up time for creating my own custom STSADM commands tremendously.

View CodePlex site to download STSADM extensions for ASP.NET AJAX

<update date="6/19/08">

Telerik has released the MOSS compatable version of the RadEditor that places all needed files as class resource files in the _wpresource directory.  They've also made some very nice improvements over the previous release that make extending and customizing the editor very easy.  If you purchase and deploy the Full-Featrured RadEditor, you get ALL of the controls in the Telerik ASP.NET AJAX control suite available to you in MOSS.  Very nice...

</update>

Yesterday I posted about using the new RadControls for ASP.NET AJAX in MOSS, and I started moving the old controls in my current project over to the new ones.  Just now, I found a problem when I was converting the RadEditor from the old to the new.

In the Telerik online documentation for getting started with the RadEditor, they say that in a standard ASP.NET AJAX application, you need to utilize the App_GlobalResources and App_Data ASP.NET folders in order to use the RadEditor.

That's not any different for MOSS.

In the root of your SharePoint Web Application (\Inetpub\wwwroot\wss\VirtualDirectories\YourWebApp) create a folder named App_Data.  Drop in the RadSpell folder from the App_Data folder of the RadControls install directory (C:\Program Files\Telerik\RadControls for ASPNET AJAX Q1 2008).  Then, drop the RESX files from the App_GlobalResources directory located at the Telerik install root into the already present App_GlobalResources directory in your SharePoint Web Application root.

I think there's probably a better a way to do this using a Solution, but I'll worry about that later.  Not sure if we can deploy into those folders via a WSP - I don't think so.  I know there's a public property on the RadEditor that allows you to point to where the RadSpell directory is, but can't find anything for the RESX files.

Also, make sure you add the following line to the HttpHandlers section of your web config file, or else, spellcheck won't work:
<addverb="*"validate="false"path="Telerik.Web.UI.SpellCheckHandler.axd"type="Telerik.Web.UI.SpellCheckHandler, Telerik.Web.UI"/>

Anyway, here's a screen shot of the unskinned and unmodified RadEditor running in my local MOSS environment.  This is not tied into a publishing placeholder, but that's not what I'm using it for right now...

I've been a huge proponent of Telerik because of their very impressive controls, support, and documentation - let alone for the fact they are very easy to use.  Now that I've been working with SharePoint 2007 for a few years, I've found that Telerik's controls fit very nicely into MOSS.  Andrew Connell even created an integration whitepaper and some nice utility EXEs to help package the individual controls into WSPs to deploy them into MOSS.

Then, on April 15 of this year, Telerik released version 2008.1 of their new RadControls Suite for ASP.NET AJAX, formerly named 'Prometheus'.  I purchased my upgrade from the old RadControl suite to the Prometheus controls yesterday, and there was something that I noticed immediately which frightened me a little.  There's only one assembly - Telerik.Web.UI.ddl - and nowhere that I could see on the Telerik site that allowed me to get an individual control.

Uh oh. 

How do I get these amazing controls into SharePoint and start benefiting from that ASP.NET AJAX goodness?  Do I package the whole thing into a WSP? I hope not! That'll be a huge WSP file with all those skins getting packaged up!

I was worried, and started thinking that I was going to be stuck with a legacy version of some great controls, being forced to sit  here watching new versions go sailing past every three months.  No way!!!

I figured that there had to be a way, and if it took a massive WSP, so be it, so I started poking around the new control suite to see how it ticked.  There's no RadControls directory, so AC's walk-through documentation won't work.

I tested the RadSlider locally, and I asked myself, where do the images come from in the control?

I got out my trusty IE Dev Toolbar and took a peak.  I liked what I saw.

WebResource.axd!

Now, I don't care if this image is an embedded resource file or not.  It's not a direct reference to an image, and that's what matters.  What happens if a skin is applied? Where's the image then?

Office2007 skin:

IE Dev Toolbar:

Still a WebResource.axd. Excellent!

So - here's the deal.  Install the entire RadControls EXE which you get via your Telerik account on your SharePoint server.  Deploy the Telerik.Web.UI.dll to your SharePoint application's bin, and add the following line to the SafeControls block in the web.config

That's it...

Then, you can use any control in the entire suite just by adding the following Register tag to the page where you're using it

No more individual control references anywhere! Sweet!

For example - the RadTreeView control:

You can even deploy this inside your custom WSP by using the various Visual Studio project templates available on CodePlex.  I know of three that support deploying other assemblies, so finding them shouldn't be hard.  I'm partial to this one, and I know stsdev is really nice, as well.  You can even reference the Telerik control assembly server-side, too.  Just make sure you set the CopyLocal property of the reference to False.

You won't get IntelliSense for the controls, but as far as MOSS dev goes - what else is new, right?  There's plenty of documentation on Telerik's site to help with the control properties and client-side API.

Here's the new RadSlider with the Office2007 skin running in one of my MOSS environment:

I've started moving over all of the controls in my current project from the old version of the suite to the new version, and there's been some minor changes, but nothing of a pain at all.  The changes I have seen have been good ones, so it's been worth it so far.  Besides, these controls ROCK!  I haven't gone through and seen which ones work and which don't, but I'm sure it'll be similar to the old version of the suite.  I know the RadSplitter was a hassle before, will have to try it again with the new ones.  I've even noticed some performance gains over the old controls.

So, if you haven't picked up on it, I highly recommend these controls.  Not only will they completely expand your MOSS UI potential, but they will get you to install Service Pack 1 and configure ASP.NET AJAX in SharePoint if you haven't yet.  Remember, SP1 is required if you want to use ASP.NET AJAX, therefore, it's required to use these controls.

Having spent a great deal of time developing Microsoft Content Management Server 2002 solutions, I've found there's a bunch of stuff I miss from the MCMS API.  The single thing I miss the most:

CmsContext.Searches.GetByGuid(string) as HierarchyItem;

Being able to get any object - Channel, Template, Posting, Resource - by just it's guid was huge.  Even cooler was that you could grab an object out of anywhere in the hierarchy/taxonomy.  In SharePoint, you have to know the Web, List, and Item guid to find anything.  This one method in MCMS allowed a huge number of possibilities for custom dev with very limited coding time.

Another thing I miss from MCMS is the functionality of Connected Postings/Templates and an API that could CRUD them without hardly any effort.  I know Variations in SharePoint comes close, but IMO, it just doesn't seem to be at the same level and simplicity of MCMS.  Also, there's very little documentation around any of the Variation related objects because they've all been marked as internal.

Luckily, Michiel Lankamp figured this out - a long time ago - using Reflector (duh) and exposed that yes, everything in SharePoint is a list(thanks Matt). As Michiel points out, there's two variation lists. One called VariationSettings and one called VariationLabels who's guids are stored as Properties on the root web of the site collection.

Once you get the lists, how do you create the hierarchy? Check out Michiel's post to see how. Pretty clever...

I haven't tried this, and based on the four comments, not many other people have, either.  Also looks like it could be buggy.

Enable variations programmatically - Michiel Lankamp

So a client came to us today complaining that their SharePoint site was dead.  Looking at the performance monitor revealed that the processor was maxed out.  SQL showed around 1300 active connections.  IISReset and bouncing of the server proved to be of little help.

We shut the firewall off to the outside and were able to get the default page of the site to render without any problems.

After going back and forth troubleshooting the server for most of the morning, we took a look at the site's default page's web part maintenance page which showed a total of 88 web parts on the page, 54 of them being closed and in the Web Part Page Gallery.  All 54 of those web parts were Content Editor Web Parts.

wow

That's a lot of web parts.  According to TechNet, the maximum recommended number of web parts on a page is 50.  What the client had been doing was adding CEWPs to the page and once the content was no longer valid, hitting the 'X' on the web part, closing it, but not deleting it.  Doing so caused SharePoint to still get the web part from the database, just not render it on the page.

According to MSDN documentation titled 'A Developer's Introduction to Web Parts':

A Web Part Page gallery contains Web Parts that are already added to the current page. This may seem paradoxical at first. Why would you need to add a Web Part that is already added to the page? The reason this is useful is that you can add a Web Part to a page and then close the Web Part. To close a Web Part, click the arrowhead on the right side of the Web Part title bar, and then click Close. A closed Web Part is no longer visible on the page, but it is still a member of the Web Part Page gallery for that page. The Web Part is still associated with the page by an entry in the configuration database of the server running Windows SharePoint Services, which also stores any shared or personalized property settings for the Web Part.

You can add a Web Part to a page, personalize it extensively, close it, and then later add it back to the page with the personalization intact. To bring back a closed Web Part, select it from the Web Part Page gallery.

Note   To truly delete a Web Part from a page, you must click the Modify My Page menu (or the Modify Shared Page menu in shared view), and then click Design this Page to add the Delete command to the drop-down menu of the Web Part. To remove the Web Part from the page without adding it to the Web Part Page gallery, click the arrowhead on the right side of the Web Part title bar, and then click Delete.

After removing 50 of the closed web parts from the Web Part Page Gallery, not only was the site back up, but the response time for the page was faster than it has been for quite some time.

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!

Being Asp.Net developers, we all know we can send email from within custom code using the virtual SMPT server running on the Web Front End server where our code is running, but what if you want to use the same SMTP/Exchange settings you configured in Central Administration?

Luckily, there's a way to do so.

I like to create an object I call SPEmail for encapsulation, then within the Send method go dig for the info I need from the SPAdministrationWebApplication.Local and it's OutboundMailServerInstance property.  Once you have these objects, the information entered in Central Admin can be obtained and be used to set up the standard System.Net.Mail SmtpClient and MailMessage objects. 

No messing with the web.config file. Nice.

Here's the code for my SPEmail object:

            public
            class SPEmail
{ #region Constructors public SPEmail()
{ } #endregion#region Private
Members string _To = string.Empty; string _Subject
= string.Empty; string _Body
= string.Empty; bool _HTML
= false; #endregion#region Public
Properties publicstring To
{ get { returnthis._To;
} set { this._To = value;
} } publicstring Subject
{ get { returnthis._Subject;
} set { this._Subject = value;
} } publicstring Body
{ get { returnthis._Body;
} set { this._Body = value;
} } publicbool IsHtml
{ get { returnthis._HTML;
} set { this._HTML = value;
} } #endregionpublicvoid Send()
{ string smtp = string.Empty; string fromAddress
= string.Empty; string replyToAddress
= string.Empty; SPSecurity.RunWithElevatedPrivileges(delegate()
{ SPAdministrationWebApplication adminApp = Microsoft.SharePoint.Administration.SPAdministrationWebApplication.Local;
SPOutboundMailServiceInstance emailService = adminApp.OutboundMailServiceInstance;
smtp = emailService.Server.Address; fromAddress = adminApp.OutboundMailSenderAddress;
replyToAddress = adminApp.OutboundMailReplyToAddress; if (!string.IsNullOrEmpty(this.To))
{ SmtpClient mail = new SmtpClient(); MailMessage
message = new MailMessage(); message.From = new MailAddress(fromAddress);
message.To.Add(this.To); if (!string.IsNullOrEmpty(replyToAddress))
message.ReplyTo = new MailAddress(replyToAddress); if (!string.IsNullOrEmpty(this.Subject))
message.Subject = this.Subject; if (!string.IsNullOrEmpty(this.Body))
message.Body = this.Body; message.IsBodyHtml = this.IsHtml;
mail.Host = smtp; mail.Send(message); } }); } }

So - if you want to write your own, there you go!

Sigh...

After I put this together, I found that you can send email from within the SPUtility object.  SPUtility.SendEmail() will take care of all this for you, too. 

Recently, I've seen a lot (read: too many) posts about the release of SP1 for WSS3 and MOSS.  I, however, wanted to post on the success of applying the upgrade.  Often, people are concerned about patches and upgrades because they may have heard a story of a friend who knew this guy, whose sister's IT department applied an upgrade to a mission critical server and it caused the stock market to crash the oceans to rise two feet. 

Well, no such luck with this set of upgrades.  Everything went fine.  Make sure you do your research and read the documentation available in the TechNet Service Pack 1 Resource Center, though.  You don't want to be applying just anything people tell you to.

One thing cool that you may have heard people mention is that ajax.asp.net is now supported in WSS3 and MOSS.  You still need to install and configure ajax.asp.net, which can cause problems if you don't do it complete and correct, but isn't too difficult.  At least now if you have problems, you can go to MS Support for help.  Here's the snippet from the SP1 Introduction Document about ajax.asp.net in wss/moss:

Beginning with Windows SharePoint Services 3.0 SP1 and Office SharePoint Server 2007 SP1, developers can use AJAX to create custom Web Parts. Developers can create Web Parts for asynchronous post back by using either the Microsoft AJAX 1.0 Control toolkit for Microsoft ASP.NET or the AJAX 1.0 Extensions for ASP.NET. See Microsoft Knowledge Base article 941955 (http://go.microsoft.com/fwlink/?LinkId=105778&clcid=0x409) for more detail on the workarounds necessary to add an UpdatePanel control to a Web Part allowing you to leverage the asynchronous AJAX postback. Note that. Service Pack 1 and the AJAX Extensions must first be installed and configured. Also, AJAX components are not included with Service Pack 1: You must download and install them separately.

After you install the AJAX components and Service Pack 1, you can get help from Microsoft customer support for that configuration.

Also, I applied Service Pack 1 for the Office 2007 Suite without any issues, either.  Hopefully, if there are issues with the upgrades, people will post what they find and how they resolved.

I'm working on a site which uses Forms Based Authentication, and I want to extend the standard user profile with some of my own custom properties.

I knew you could define a ProfileProvider in the MOSS web.config file, but the tricky part was getting and setting the values since the framework is unaware of the provider.  You can't access the properties at design-time like a normal Asp.Net Web Application, and I couldn't find any documentation for accessing Profile Provider Properties as a collection like propcollection["propname"].  I've seen a couple places where people talk about creating and using custom profile provider properties in MOSS, but there was nowhere that explained how to do it.

Then, yesterday there was the post on the MOSS Team Blog about the Profile Import Tool being released on CodePlex - which is very cool in itself.  I figured, CodePlex - open source; Profile Import - I bet they have code in their project that gets the properties out in the way I need since it's a dynamic process for importing profile property values.  Bingo!  Thank you Steve, Ron, and Lawrence!

Here's the code I used to Get/Set a custom profile property named 'UserCity' for the current user in MOSS, most of which was pulled and pieced together from the Profile Import Tool project:

Profile section in MOSS web.config:

            <
            profile
            defaultProvider
            ="MOSSPortalProfile"
            enabled
            ="true"
            automaticSaveEnabled
            ="true"
            >
            <
            providers
            >
            <
            add
            connectionStringName
            ="AspNetDb_ConnectionString"
            applicationName
            ="MOSSPortal"
            name
            ="MOSSPortalProfile"
            type
            ="System.Web.Profile.SqlProfileProvider,System.Web,Version=2.0.0.0,Culture=neutral,PublicKeyToken=b03f5f7f11d50a3a"
            />
            </
            providers
            >
            <
            properties
            >
            <
            add
            name
            ="UserCity"
            customProviderData
            ="DisplayName=City;"
            />
            </
            properties
            >
            </
            profile
            >
          

Get/Set C# code:

            //object
to hold the profile properties defined in the web config SettingsPropertyCollection
profileProperties = new SettingsPropertyCollection(); //get
the profile section from the web config ProfileSection profileConfigSection
= (ProfileSection)ConfigurationManager.GetSection("system.web/profile"); //get
the collection of defined properties RootProfilePropertySettingsCollection
configProperties = profileConfigSection.PropertySettings; //create
collection to contains properties to pass to the profile provider SettingsPropertyCollection
propertiesToReturn = new SettingsPropertyCollection(); //populate
the collection with properties from the web configforeach (ProfilePropertySettings
configProperty in configProperties) { SettingsProperty
profileProperty = new SettingsProperty(configProperty.Name);
profileProperty.PropertyType = Type.GetType(configProperty.Type); if (profileProperty.PropertyType
== null) { profileProperty.PropertyType = typeof(System.String);
} profileProperty.DefaultValue = configProperty.DefaultValue; propertiesToReturn.Add(profileProperty);
} //get the profile provider ProfileProvider provider
= ProfileManager.Providers["MOSSPortalProfile"]; //create
a SettingsContext for the current user SettingsContext userContext = new SettingsContext();
userContext["UserName"] = SPContext.Current.Web.CurrentUser.Name;
userContext["IsAuthenticated"] = true; //get
the values of the properties for the current user from the database SettingsPropertyValueCollection
returnVal = provider.GetPropertyValues(userContext, propertiesToReturn); //get
the value out of the collectionstring contactCity
= Convert.ToString(returnVal["UserCity"].PropertyValue); if (contactCity
== string.Empty) { contactCity = "Denver";
} //set value returnVal["UserCity"].PropertyValue
= contactCity; //save user profile properties back to
the database provider.SetPropertyValues(userContext, returnVal);

Just completed applying the security rollups for WSS/MOSS to fix the Elevation of Privilege security vulnerability as well as fixing the daylight savings time change issues.  I followed Shane Young's post on performing the install and it was relatively painless and worked fine.  I did see the 'Failure to start service SPSearchServiceInstance...' warning during step 8, but running stsadm -o osearch -action start (as described on TechNet) after the configuration wizard completed restarted the Search service without any problems.

One thing I was a little confused about was the proper order of how to apply things in a farm because of the warning that pops up in the Configuration Wizard about needing to install the updates and run the Configuration Wizard on all other servers before the one currently being configured.  Shane describes his install for only one server, and Joel Oleson says that you need to install and run everything on all servers on his FAQ about the patches, but doesn't give any particular order.

I really don't think it the order matters, but here's what I did on my 2x1 farm (2 WFEs and 1 Application Server).  Central Admin runs on the App server.

1) Installed the executables on all servers.  The WFEs required reboots after each patch was applied.

2) Ran the Configuration Wizard on the App server.

3) Ran the Configuration Wizard on the WFEs.

I think that the only thing that matters is that the patches are applied to all servers in the farm before the Configuration Wizard is run anywhere.  Then it doesn't matter the order of the servers that you run the Configuration Wizard, just make sure you run it on all of them.

The Community Kit for SharePoint: Internet/Extranet Edition (CKS:IEE) is a tool that contains many useful pieces for both users and administrators of a publicly accessible SharePoint site and extends the already powerful Forms Based Authentication functionality of MOSS.

Here's the play-by-play for installing the CKS:IEE and creating an anonymously accessible Internet site that has FBA enabled for sub-sites using the CKS:IEE:

1) Go to the CodePlex site for the CKS:IEE project.

2) The CKS:IEE doesn't set up Forms Based Authentication so I needed to follow the post by Dan Attis: Office SharePoint Server 2007 - Forms Based Authentication (FBA) Walk-through - Part 1.  If you haven't set up Forms Based Authentication yet, this is THE post to follow, as it gets FBA up and running with minimal complexity. I set my site up with the Collaboration Portal template, rather than the Blank Site that Dan used in his post. 

Make sure you can browse to the site and login using the default MOSS FBA login page before you install the CKS:IEE solution.

3) Download FBAManagement.zip from the CodePlex site, extract all the files, and run deploy [your_site_url] from a command prompt.  The wsp will be added to the solution store, deployed to the site specified, and the features will be activated.

4) Edit the default page of your site, add the Login Web Part to the page from the FBA Self Management group on the Add Web Part dialog.
 

Set the Chrome Type on the Login Web Page to None.  This will hide the web part when a user is logged in.

5) I want to have the default page of the site be anonymous, so that when users go to the URL, they are presented with the home page, not the login page.  To set up anonymous access, I followed Bil Simser's post Enabling anonymous access in SharePoint 2007.  I had to close all browser windows after I followed Bil's steps to get it working right. 

When I went back to the site, here's what I saw:

You'll notice that everything is visible to the unauthenticated user. Document Center, News, Reports, etc.  When you first set up anonymous access, everything is accessible to the anonymous user, so you need to scale back the permissions on the sub-sites.  This is accomplished by editing the permission on the sub-sites, and then turning off anonymous access.

a) Break inheritance by clicking 'Edit Permissions' in the Actions menu of the Site Permissions list of the sub-site.

b) Click the Anonymous Access link of the now visible Settings menu.

c) Click the radio button to allow anonymous users to access nothing.

I did this for all subsites, and here's how it looked when browsed by an unauthenticated user.

The View All Site Content link is still there in the Quick Launch, but you can deal with that later when you set up your custom master pages and page layouts.

6) The Login Web Part understands the QueryString values that are present in the URL if the user is trying to access a page they don't have permissions to (ie: ?ReturnUrl=%2fSearchCenter%2f_layouts%2fAuthenticate.aspx%3fSource%3d%252fSearchCenter&Source=%2fSearchCenter) This way you can have a page that is managed via CMS services, and when the user logs in correctly, they will be taken to the page they were originally trying to access. 

The first step for this to happen is to change the forms login page in the web.config for the site. Change the line

<forms loginUrl="/_layouts/login.aspx" />

to

<forms loginUrl="/Pages/login.aspx" />

Now, create a new page in the root site's Pages library named Login.  Add some text like 'You are trying to access a page with invalid permissions, please try again.' and add the login web part.  Should look something like this:

Publish the page. 

That's it! We now have a publicly accessible site with Forms Based Authentication that has a default page with anonymous access, and a login page that is managed by SharePoint with CMS content placeholders on it, rather than the flat out-of-box login page.

I plan on having posts that explain using the other web parts included with the CKS:IEE, and I'm also looking to put a custom workflow on the Site Membership Review List. So stay tuned...

Just received a nice little sting...

I love the Telerik Editor for MOSS, so I use it almost on every page.  I wanted to perform an upgrade to the 4.4.0.0 version, but I just got slammed by a big gotcha!

I've always followed the Telerik documentation for adding the editor to a page layout.  But I must say, after today, I don't agree at all!

When Telerik releases a new version of the RadEditor, they change the version number on the assembly, naturally.  The downfall of this is that because of the new version number, you have to go to every page layout and change the version number in the Register tag at the top of the page.  This stinks!

To keep yourself from having this same problem, place the control reference in the web config file of the sites that you are using the RadEditor.  This will allow you to update the control reference only once next time, not on every single page layout file.

This should be done for all Telerik controls used on page layouts...

Here's another little thing that might be worth doing:
The image browser in the RadEditor for MOSS doesn't allow you to traverse the site structure like the OOB MOSS RichTextEditor, therefore you can't choose images from the SiteCollectionImages library.  To fix this, open the editor's tools file (located at \Program Files\Common Files\Microsoft Shared\web server extensions\wpresources\RadEditorSharePoint\4.1.0.0__1f131a624888eeed\RadControls\Editor) and rename the ImageManager tool to MOSSImageManager.  Got this gem on the Telerik forum...

Bless me father, for I have silenced.  It's been 22 days since my last posting.

Ahhh... So I'm stoked that I now have some new ground to break! The last gig is just about up, and I'm getting ready to start on the next one.  This is one of my favorite points in a project.  The blank slate. The white canvas.

Looks like this one's going to be an Internet facing branding portal, where the client can provide advertising and marketing agencies with brand guidelines and product images.  The client previously used a graphics server product that was built by Adobe, but is no longer supported.  Equilibrium's MediaRich for SharePoint product looks like it's going to be a good fit in MOSS for the needs that the client has.

This client also has some interesting requirements around how a user is able to access the site, and it looks like the Community Kit for SharePoint: Internet/Extranet Edition Forms-Based Authentication solution is going to hit the mark pretty close.  We're going to need a custom workflow on the Site Membership Review List, but that should be fairly easy to integrate into the solution.

We're going to be doing some CMS with some heavy customizations, too, so that should be a lot of fun.  We've got a very talented designer that we're working with, and I can't wait to see how the final product is going to look.  From the comps I've seen, it's going to be very slick. 

I'm also looking forward to getting back to the blogging.  Being that we've got the CKS: Internet and MediaRich lined up, I'm hoping to document the process of the install and configuration, as well as the migration of client's digital assets from the old, unsupported Adobe product to the Equilibrium product.  Did I mention that the Adobe product is no longer supported? Well, it's not. Nice.

So, stay tuned.  I'm warming up a new VHD in my dev domain in the morning...

With all the talk about SharePoint as an application platform lately, I figured it might be good to post on the way I like to describe SharePoint to clients.

Sure, you get a lot of neat features out of the box with SharePoint, but I've seen plenty of deer-in-headlight looks after people hear everything the product has to offer and the exponential amount of solutions that are possible when you look a little deeper.  Even after conversing a great deal about what SharePoint is and how it can help an organization, there are always a few folks who have that 'but... I don't get it!' look.  Usually, it's the business-focused people who understand the idea of SharePoint right away, but I've found that it's the folks who are deep-technical in nature, but have been exposed to MOSS only through reading some articles and maybe been through a little training, who have a harder time grasping the SharePoint concept.  Let's face it, it's a new way of thought for most techies.

One thing I heard in February 2006 struck a cord with me for some reason: 'Everything in SharePoint is a list.'  Got me thinking.  I did a ton of MCMS02 development, so I was used to performing app dev as using a robust API, and not heavily leveraging SQL.  Couple that with the article Gathering MOSS in the August 2006 issue of MSDN by one of the newest members of the MOSS blogging community, Ted Pattison, app dev in WSSv3 clicked.

Almost every client that I've talked to about SharePoint has had at least some technical experience in their careers, and even if they haven't, they probably are familiar with the way a database is set up, so why not have them think about SharePoint in way that they already understand?

When I've explained this, I always see the light bulb go on:

WSSv3 even introduces index columns and cross-list querying to allow for more database comparisons, and there are plenty others.

With the current argument going on around SharePoint as an application platform, maybe this will help those folks who are against the platform have the light bulb go on, too.  Sure, as AC and Joel have said, the developer experience might not be the greatest right now, but give it time.  At least it's better than punch cards!

----------

Note - yes, I know that all applications aren't meant to be in SharePoint, but I can see how all applications could be... ;)

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"?><!--
_lcid="1033" _version="12.0.4518" _dal="1" --><!--
_LocalBinding --><Templatesxmlns:ows="Microsoft
SharePoint"><TemplateName="CustomSiteExample"ID="111000"><ConfigurationID="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...

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:

When creating a content crawl schedule in MOSS, after pressing ok, the form came back with an access denied message...

Error message: ERROR: Access is denied. (Exception from HRESULT: x80070005 (E_ACCESSDENIED))

Resolution: http://support.microsoft.com/default.aspx/kb/926959

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><SafeControlSafe="True"Assembly="3rdParty,
Version=4.3.8.0, Culture=neutral, PublicKeyToken=kjh2kh32kjh21j"Namespace="3rdParty.WebControls"TypeName="*"/></SafeControls></Assembly></Assemblies><Resources><ResourceLocation="CustomResources\CustomResources.en-US.resx"/><ResourceLocation="CustomResources\CustomResources.resx"/></Resources><FeatureManifests><FeatureManifestLocation="CustomFeature1\Feature.xml"/><FeatureManifestLocation="CustomFeature2\Feature.xml"/></FeatureManifests><RootFiles><RootFileLocation="CustomResources\CustomResources.en-US.resx"/><RootFileLocation="CustomResources\CustomResources.resx"/></RootFiles></Solution>

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

            <!--
To modify your build process, add your task inside one of the 
             targets
below and uncomment it. 
             Other similar extension
points exist, see Microsoft.Common.targets.
             <Target
Name="BeforeBuild">
             </Target>
             <Target
Name="AfterBuild">
             </Target>
             -->
          

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!

So, The Mossman commented on my post yesterday saying that a little source around the PSMP would be nice, so just for him, here it is.  I figured it would be good to build on Andrew Connell's Telerik MOSS Integration Guide, so this example shows how to create your own top-level menu in a custom server-control using the Telerik RadMenu and the PortalSiteMapProvider.  I know not everybody will have the license for the Telerik RadMenu, so if you don't, hopefully you'll be able to take this example and pull out of it what you need.

Also, I posted this post on top of the one yesterday, whoops.  There's a good lesson on locally saving your postings. Sorry if it's shown up new a couple of times for some of you. Wish I could figure out why...

This solution shows how you could add custom attributes on each RadMenuItem from SPField values in the PublishingPage along with a custom client-side script event handler.

Download the source for the complete control in a text file, if you'd like it.

The menu created will look like the following and will pop a JavaScript alert with the relevant PublishingPage and SPWeb GUIDs when clicked:

 

            

              protected
              override
              void CreateChildControls()
{ //Get the root publishingweb web for the site PublishingWeb
rootWeb = PublishingWeb.GetPublishingWeb(SPContext.Current.Site.RootWeb); //Get
the URL of the default page in the webstring defaultPageUrl
= rootWeb.DefaultPage.ServerRelativeUrl; //find the item
in the PSMP PortalListItemSiteMapNode smnHome = (PortalListItemSiteMapNode)PortalSiteMapProvider.

            

CurrentNavSiteMapProviderNoEncode.FindSiteMapNode(defaultPageUrl); //initialize
the RadMenu RadMenu menu = new RadMenu();
menu.ID = "MainMenu"; menu.RadControlsDir = "/_wpresources/RadMenu.Net2/4.3.2.0__bbe59a8ad3533e68/RadControls";
menu.Skin = "Outlook"; //Set
the client-side clicked event handler menu.OnClientItemClicked = "MainMenu_RadMenuItemClicked"; //create
the first menu item for the default (home) page RadMenuItem rmiHome = createMenuItem(smnHome);
menu.Items.Add(rmiHome); //iterate through each one of
the pages and subsites and create menu items for themforeach (SiteMapNode
smnTopLevelItem in smnHome.ParentNode.ChildNodes)
{ RadMenuItem rmiTopLevelItem = createMenuItem(smnTopLevelItem); //if
the current sitemap has children, create a submenu for itif (smnTopLevelItem.HasChildNodes)
{ foreach (SiteMapNode smnChildItem in smnTopLevelItem.ChildNodes)
{ RadMenuItem rmiChildItem = createMenuItem(smnChildItem); rmiTopLevelItem.Items.Add(rmiChildItem);
} } menu.Items.Add(rmiTopLevelItem); } this.Controls.Add(menu); //create
the client-side script for the RadMenuItemClicked event handler StringBuilder
sbScript = new StringBuilder(); sbScript.Append(Environment.NewLine
+ "<script language=\"javascript\">"); sbScript.Append(Environment.NewLine
+ "function MainMenu_RadMenuItemClicked(sender, eventArgs)");
sbScript.Append(Environment.NewLine + "{"); sbScript.Append(Environment.NewLine
+ "var pageGuid = eventArgs.Item.GetAttribute(\"PageGuid\");");
sbScript.Append(Environment.NewLine + "var webGuid =
eventArgs.Item.GetAttribute(\"WebGuid\");"); sbScript.Append(Environment.NewLine
+ "alert(\"WebGuid:\" + webGuid + \" PageGuid:\" + pageGuid);");
sbScript.Append(Environment.NewLine + "}"); sbScript.Append(Environment.NewLine
+ "</script>"); this.Page.ClientScript.RegisterStartupScript(typeof(string), "RadMenu_MainMenu_RadMenuItemClicked",
sbScript.ToString()); } /// <summary>///
Create a RadMenuItem from a SiteMapNode/// </summary>///
<param name="siteMapNode">SiteMapNode used to create RadMenuItem </param>///
<returns>RadMenuItem</returns>private RadMenuItem
createMenuItem(SiteMapNode siteMapNode) { RadMenuItem menuItem = new RadMenuItem();
menuItem.NavigateUrl = siteMapNode.Url; menuItem.Text = siteMapNode.Title; SPListItem
listItem = null; //if
the SiteMapNode is the default page, it will be a PortalWebSiteMapNodeif (siteMapNode is PortalWebSiteMapNode)
listItem = getListItemFromPortalSiteMapNode((PortalWebSiteMapNode)siteMapNode); if (siteMapNode is PortalListItemSiteMapNode)
listItem = getListItemFromPortalSiteMapNode((PortalListItemSiteMapNode)siteMapNode); //create
the custom attributes on the list itemif (listItem
!= null) { menuItem.Attributes.Add("PageGuid",
listItem.UniqueId.ToString("N")); menuItem.Attributes.Add("WebGuid",
listItem.Web.ID.ToString("N")); menuItem.ToolTip
= listItem.Fields["MenuItemToolTip"].GetFieldValueAsText(listItem["MenuItemToolTip"]);
} else { menuItem.Attributes.Add("PageGuid", string.Empty);
menuItem.Attributes.Add("WebGuid", string.Empty);
menuItem.ToolTip = siteMapNode.Title; } return menuItem;
} private SPListItem getListItemFromPortalSiteMapNode(PortalListItemSiteMapNode
siteMapNode) { SPWeb web = SPContext.Current.Site.AllWebs[siteMapNode.WebId]; PublishingWeb
pubWeb = PublishingWeb.GetPublishingWeb(web); SPListItem pageItem = pubWeb.PagesList.Items[siteMapNode.UniqueId]; return pageItem;
} private SPListItem getListItemFromPortalSiteMapNode(PortalWebSiteMapNode
siteMapNode) { SPWeb web = SPContext.Current.Site.AllWebs[siteMapNode.WebId]; PublishingWeb
pubWeb = PublishingWeb.GetPublishingWeb(web); SPListItem pageItem = null; if(pubWeb.DefaultPage
!= null) pageItem = pubWeb.PagesList.Items[pubWeb.DefaultPage.Item.UniqueId]; return pageItem;
}

          

I was talking to a client who was having difficulty developing a navigation control using the methods described in most of the documentation out there, which explains creating a custom Site Map Provider which inherits from the PortalSiteMapProvider (PSMP)object.  There was just no way they were going to get exactly what they were looking for in relation to what their high-priced 3rd-party designer delivered.

After taking some time to do some exploration, and being a big proponent of web server controls in the MOSS context, I knew this was the way they needed to go.  I found a great post by Chris Richard on the MS ECM Team Blog that explained how the PortalSiteMapProvider deals with performance issues found often in costly navigation rendering routines.  This post also explained how to use the PSMP object in custom code - something that caught my eye.

There are a few instances of the PSMP that are defined in the MOSS web.config that can be accessed through the PSM object:
PortalSiteMapProvider.CombinedNavSiteMapProvider: attached to the global or top nav menus
PortalSiteMapProvider.CurrentNavSiteMapProvider: attached to the current, or "Quick Launch" nav menu
PortalSiteMapProvider.CurrentNavSiteMapProviderNoEncode: attached to the breadcrumb nav
PortalSiteMapProvider.GlobalNavSiteMapProvider: Get the map for the global nav
PortalSiteMapProvider.WebSiteMapProvider: enumerates Web sites (SPWebs) in the site collection

Essentially, all of these object are set with the current SPContext, so they are already security-trimmed and ready to use as-is for the user currently browsing the site.  The special one for me here is the CurrentNavSiteMapProviderNoEncode, which includes the pages, not just the webs. There is a limitation which Chris mentions in that this provider doesn't return the default page in a web, rather just a reference to the web itself, but that's ok - he explains a workaround to this if you're interested...

Essentially, my client's problem is that they have a left-side tree navigation, kind of.  There's some interesting display logic that, like I said earlier, just doesn't work with the out-of-box implementation. Without going into what they really needed to accomplish, I figure it would be good to explain how to use the object to answer some of the common questions in a custom navigation scenario.

1) Where Am I Now?
2) Where's That Page?

Luckily, the CurrentNavSiteMapProviderNoEncode has a method that makes finding stuff pretty easy.  FindSiteMapNode(). This method has three overloads, all which return a SiteMapNode object.

The first overload takes an HttpContext as a parameter and is great for finding where you're at now.  The second overload takes a URL and can be used for finding any SiteMapNode given the URL provided.  The third takes both a URL and an SPWeb object as context.

Here's some examples on how you use this along with the Publishing object model:

            //In
a server control, find the SiteMapNode for the current HttpContext  SiteMapNode
siteNode = PortalSiteMapProvider.CurrentNavSiteMapProviderNoEncode.FindSiteMapNode(Context); ///
<summary> /// Find SiteMapNode for PublishingWeb
object /// </summary> ///
<param name="web">PublishingWeb object to retrieve in PortalSiteMapProvider</param> ///
<returns>SiteMapNode object representing given PublishingWeb object</returns> protected SiteMapNode
GetSiteNodeForPubWeb(PublishingWeb web) { string url
= web.Url + "/" + web.DefaultPage.Url; SiteMapNode
siteNode = PortalSiteMapProvider.CurrentNavSiteMapProviderNoEncode.FindSiteMapNode(url); return siteNode;
} 

The SiteMapNode object contains everything needed to walk around in the hierarchy of the PSMP, and should allow you conquer any custom display logic any tricky designer can throw at you...

Update: I added a follow-up post to this one with some Sample Code for a Custom C# MOSS Navigation Using PortalSiteMapProvider

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
            >
            <!--
Class Resources Go Here -->
            </
            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
            >
            <!--
Class Resources Go Here -->
            </
            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"
            />
            <!--
To modify your build process, add your task inside one of the targets below and uncomment
it. 
             Other similar extension points exist, see
Microsoft.Common.targets.
             <Target Name="BeforeBuild">
             </Target>
             <Target
Name="AfterBuild">
             </Target>
             -->
          

with

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

Download all Telerik manifest entries

The documentation in the online help for the Telerik MOSS Editor doesn't explain how to enable the spell checker, which you'll want to do since the MOSS spell check will check the HTML embedded in the editor resulting in unwanted results.

There are two version of the spell checker, an inline AJAX version, and a dialog-box based version.

The AJAX version is inline with the text, and is similar to the feel of GMail's spell checker.
 

The dialog-box based spell checker is more like Word's.

To enable the Telerik editor's spell checker, enter one of the following lines into the ToolsFile.xml file located at %PROGRAMFILES%\Microsoft Shared\web server extensions\wpresources\RadEditorSharePoint\4.1.0.0__1f131a624888eeed\RadControls\Editor:

<tool name="SpellCheck"/> for the dialog-box based spell checker
<tool name="AjaxSpellCheck"/> for the Ajax spell checker

This is the same as for the standard Telerik RadEditor for ASP.Net, whose documentation can be found here: http://www.telerik.com/help/aspnet/editor/CustomizingRadSpell.html

After working in my local development environment for a few days, I was ready to deploy a Solution Package containing some publishing layout pages into our testing environment.

Once the solution deployment was complete, I tested one of the four page layouts by creating a new publishing page.  Immediately, the page rendered with the error 'Only Content controls are allowed directly in a content page that contains Content controls.' 

I thought, weird, it works on my machine, so I went and checked out the Pages list in the Web.  The page had been created correctly, and I could view the properties, so what's the deal?

Then I went to the Page Settings page via the URL, and changed the Page Layout to one of the other three page layouts in my Solution Package - no luck.  Went back and tried it with a third page layout, and to my surprise, it rendered without any issues or errors.  The fourth one worked, too.  I actually saw this as bad news since I couldn't blame the issue on anyone or anything but myself - or so I thought.  Remember, it worked on my machine!

I assumed the problem had to be something similar in the two page layouts, which were only markup, so I slowly tried whittling away pieces of markup to hopefully find the offending tag.  This was a brutally painful process because since I wasn't receiving the error locally, I had to build the .wsp, move it to test, deploy it, and run the page.  Each change and deployment took around 15-20 minutes - ouch.

After a few hours of trying this method with no luck, I wondered if the code was even being updated in SharePoint since I was using both the -removesolution/-deploysolution and the -upgradesolution methods.  The solution packages seemed to be getting deployed successfully and my page layouts were showing code changes in the FEATURES folder, so I went to the Master Page Gallery to see if the code was getting updated in the server.

Luckily, you can download copies of aspx pages from the Master Page Gallery just like they were any other kind of document by clicking the drop down for the document and choosing Send to > Download a copy.

When I viewed the markup of the page, I noticed that the code hadn't changed since the initial deployment! Normally, when you upgrade a solution, it does, so I was confused.  As I looked through the source a little further, I noticed at the bottom a strange snippet just after the closing tag for the last Content tag:

            

              </
              asp:Content
              >
              <
              html
              xmlns:mso
              ="urn:schemas-microsoft-com:office:office"
              

              xmlns:msdt
              ="uuid:C2F41010-65B3-11d1-A29F-00AA00C14882"
              ><
              head
              >
              <!--[if
gte mso 9]><xml>
              <mso:CustomDocumentProperties>
              <mso:ContentType
msdt:dt="string">Page Layout</mso:ContentType>
              <mso:PublishingAssociatedContentType
msdt:dt="string">;#Custom Page Layout Content Type;
              #0x01010007FF3E057FA8AB4AA42FCB67B453FFC100E214EEE741181F4E9F7ACC43278EE81100
              2D7E961EBCD042C6A40B97F107579F70;#</mso:PublishingAssociatedContentType>
              </mso:CustomDocumentProperties>
              </xml><![endif]-->
              <
              title
              >PageLayoutTitle</title></head>
          

Hey - those are the properties I set when I provision the files into the Master Page Gallery on activation of the feature! Well, that explains the Content controls error, but why is it in there? And, why isn't the code being updated on upgrade of the solution package?

I thought that maybe I could just delete the two offending page layouts, upgrade the solution package again, and the page layouts will be replaced.  I deleted the page I created using the page layout, then went to delete them from the Master Page Gallery.  Another error!  This time, it was the 'This item cannot be deleted because it is still referenced by other pages' error.

After searching around, I came across Katrien De Graeve's blog which explains a nice hack for removing pages from the Gallery when you see this error.  Once the pages were gone, I was able to re-upgrade the solution package, but I was still seeing the Content controls error, and the properties were still being inserted into the page markup.

Opening the page layout in SharePoint Designer proved to be some help.  I was able to remove the properties from the bottom of the page, save it, and it rendered without any errors.  That helped a little, but not if I have to do that every time I deploy the code.

I took the markup of one of the working page layouts in the solution package and replaced the markup of the one of the broken page layouts.  It worked! I slowly started piecing the page layout back together by pasting in little sections at a time until I found the offending markup.  By the time all the markup was back in there, I had seen no errors.

So - this leads me to believe that there was something imbedded into the page that I couldn't see which was causing the error.  Pasting the code in fixed whatever it was.  I'm assuming that I could have easily just pasted all the markup into Notepad, and then back into the Visual Studio editor, too, saving a ton of time.  If you have any ideas on what it could have been, please let me know.

Update (9/7/2007): Found that for some reason, one of the <asp:Content> controls became lowercase somehow, as in <asp:content>.  As soon as the casing was fixed, worked like a champ...

My friend Mark is working on a MOSS project where all authenticated users have access to the web application, but because they might not have browsed the site yet, he wasn't able to get an SPUser object for them because they weren't yet in the content database.

I'm big fan of the Contact object in the Microsoft.Office.Workflow.Tasks.dll, so we started down the path using this object, and figured out the code to make it happen:

Contact contact = Contact.FromName("domain\\name",
SPContext.Current.Web); if (contact.PrincipalID
< 0) { SPContext.Current.Web.AllowUnsafeUpdates = true;
SPPrincipal p = contact.GetPrincipal(SPContext.Current.Web); } SPUser newUser = SPContext.Current.Web.SiteUsers[contact.LoginName];

Here's how I know it works:
Before this came up, I hadn't granted 'all authenticated users' access to my dev site yet.  To test the code, I gave all authenticated users access as readers to the root web of the site, added a new user to my domain, then ran the code looking for the new user's user name.  

You might run into security issues with this code in your running app because of SPContext, but you can always elevate privileges if you need to.

I found that the user is added to the 'People and Groups: All People' list.  This should be interesting in large population situations.  If anybody has any thoughts, please let me know...

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
{ publicclass DeployCustomResourcesJob
: SPJobDefinition { #region Fields [Persisted] privatestring _SourcePath; privatestring _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 directorythis._SourcePath
= SPUtility.GetGenericSetupPath("Template"); //uncomment
the following line (commented to fix a bug in livewriter)//
+ "\\FEATURES\\" + featureName; } #endregion#region Job
Handling publicoverridevoid 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 pathstring destPath =
Path.Combine(settings.Path.ToString(), "App_GlobalResources"); //get
the RESX files from the feature directorystring[]
filePaths = Directory.GetFiles(this._SourcePath, "*.resx"); //copy/overwrite
the RESX files into the App_GlobalResource directoryforeach (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
{ publicclass CustomResourceReceiver
: SPFeatureReceiver { #region Constants conststring JOB_TITLE
= "Deploy Custom Resources"; conststring JOB_NAME
= "job-deploy-custom-resources"; #endregion#region Events publicoverridevoid FeatureActivated(SPFeatureReceiverProperties
properties) { SPWeb web = properties.Feature.Parent as SPWeb; //check
for an exisiting instance of the job - if we find it, delete itforeach (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(); } publicoverridevoid FeatureDeactivating(SPFeatureReceiverProperties
properties) { SPWeb web = properties.Feature.Parent as SPWeb; //delete
the job, if there is oneforeach (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 } publicoverridevoid FeatureInstalled(SPFeatureReceiverProperties
properties) { //throw new Exception("The method or operation
is not implemented."); } publicoverridevoid 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" ?><SolutionSolutionId="ENTER_SOLUTION_ID_GUID_HERE"xmlns="http://schemas.microsoft.com/sharepoint/"ResetWebServer="TRUE"><Assemblies><AssemblyDeploymentTarget="GlobalAssemblyCache"Location="MOSSFeatures.dll"><SafeControls><SafeControlSafe="True"Assembly="MOSSFeatures,
Version=1.0.0.0, Culture=neutral, 

                     PublicKeyToken=ENTER_YOUR_PUBLIC_KEY_HERE"
                     Namespace="MOSSFeatures"TypeName="*"/></SafeControls></Assembly></Assemblies><Resources><ResourceLocation="CustomResources\CustomResources.en-US.resx"/><ResourceLocation="CustomResources\CustomResources.resx"/></Resources><FeatureManifests><FeatureManifestLocation="CustomResources\Feature.xml"/></FeatureManifests><RootFiles><RootFileLocation="Resources\CustomResources.en-US.resx"/><RootFileLocation="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:

            

              <!-- _lcid="1033" _version="12.0.4518" _dal="1" -->
              <!--
_LocalBinding -->
              <
              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:ContentPlaceHolderid=PlaceHolderPageTitlerunat="server"/></Title><SharePoint:ThemeID="Theme1"runat="server"/><SharePoint:ScriptLinkID="ScriptLink1"language="javascript"name="core.js"Defer="true"runat="server"/><SharePoint:CustomJSUrlID="CustomJSUrl1"runat="server"/><SharePoint:SoapDiscoveryLinkID="SoapDiscoveryLink1"runat="server"/><SharePoint:CssLinkID="CssLink1"runat="server"/><styletype="text/css"> /****
Overriding styles for branding ~ located in the CSSSTyleLibrary ****/ @import url(/CSSStyleLibrary/name.css); </style><asp:ContentPlaceHolderid="PlaceHolderAdditionalPageHead"runat="server"/><SharePoint:DelegateControlID="DelegateControl1"runat="server"ControlId="AdditionalPageHead"AllowMultipleControls="true"/></HEAD><BODYscroll="yes"onload="javascript:if
(typeof(_spBodyOnLoadWrapper) != 'undefined') _spBodyOnLoadWrapper();"><formid="Form1"runat="server"onsubmit="return
_spFormOnSubmitWrapper();"><WebPartPages:SPWebPartManagerid="m"runat="Server"/><!---
--- --- Top Toolbar --- --- ---><asp:ContentPlaceHolderid="PlaceHolderGlobalNavigation"runat="server"><spanid="TurnOnAccessibility"style="display:none"><ahref="#"class="ms-skip"onclick="SetIsAccessibilityFeatureEnabled(true);UpdateAccessibilityUI();return
false;"><SharePoint:EncodedLiteralID="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
              >
              <!--
Global Breadcrumb -->
              <
              asp:ContentPlaceHolder
              id
              ="PlaceHolderGlobalNavigationSiteMap"
              runat
              ="server"
              >
              <
              asp:SiteMapPath
              SiteMapProvider
              ="SPSiteMapProvider"
              id
              ="GlobalNavigationSiteMap"
            
            

              RenderCurrentNodeAsLink
              ="true"
              SkipLinkText
              =""
              NodeStyle-CssClass
              ="ms-sitemapdirectional"
              runat
              ="server"
              />
              </
              asp:ContentPlaceHolder
              >
              <!--
Variations, Welcome Menu, My Site, My Links, Help -->
              <
              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=0src="/_layouts/images/helpicon.gif"alt="<%$Resources:wss,multipages_helplinkalt_text%>"
   runat="server"></a></asp:ContentPlaceHolder><!---
--- --- End of Top Toolbar --- --- ---><!---
--- --- Site Header --- --- ---><SharePoint:SiteLogoImageid="onetidHeadbnnr0"LogoImageUrl="/_layouts/images/titlegraphic.gif"runat="server"/><asp:ContentPlaceHolderid="PlaceHolderSiteName"runat="server"><SharePoint:SPLinkButtonrunat="server"NavigateUrl="~site/"id="onetidProjectPropertyTitle"><SharePoint:ProjectPropertyID="ProjectProperty1"Property="Title"runat="server"/></SharePoint:SPLinkButton></asp:ContentPlaceHolder><!---
--- --- End of Site Header --- --- ---><!---
--- --- Search --- --- ---><asp:ContentPlaceHolderid="PlaceHolderSearchArea"runat="server"><SharePoint:DelegateControlID="DelegateControl5"runat="server"ControlId="SmallSearchInputBox"/></asp:ContentPlaceHolder><!---
--- --- End of Search --- --- ---><!---
--- --- Horizontal Top Navigation Bar --- --- ---><asp:ContentPlaceHolderid="PlaceHolderTopNavBar"runat="server"><asp:ContentPlaceHolderid="PlaceHolderHorizontalNav"runat="server"><SharePoint:AspMenuID="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/><StaticMenuItemStyleCssClass="ms-topnav"ItemSpacing="0px"/><StaticSelectedStyleCssClass="ms-topnavselected"/><StaticHoverStyleCssClass="ms-topNavHover"/><DynamicMenuStyleBackColor="#F2F3F4"BorderColor="#A7B4CE"BorderWidth="1px"/><DynamicMenuItemStyleCssClass="ms-topNavFlyOuts"/><DynamicHoverStyleCssClass="ms-topNavFlyOutsHover"/><DynamicSelectedStyleCssClass="ms-topNavFlyOutsSelected"/></SharePoint:AspMenu><SharePoint:DelegateControlID="DelegateControl6"runat="server"ControlId="TopNavigationDataSource"><Template_Controls><asp:SiteMapDataSourceShowStartingNode="False"SiteMapProvider="SPNavigationProvider"id="topSiteMap"runat="server"StartingNodeUrl="sid:1002"/></Template_Controls></SharePoint:DelegateControl></asp:ContentPlaceHolder><!--
Site Actions Menu --><SharePoint:SiteActionsrunat="server"AccessKey="<%$Resources:wss,tb_SiteActions_AK%>"id="SiteActionsMenuMain"PrefixHtml="&lt;div&gt;&lt;div&gt;"SuffixHtml="&lt;/div&gt;&lt;/div&gt;"MenuNotVisibleHtml="&amp;nbsp;"><CustomTemplate><SharePoint:FeatureMenuTemplateID="FeatureMenuTemplate1"runat="server"FeatureScope="Site"Location="Microsoft.SharePoint.StandardMenu"GroupId="SiteActions"UseShortId="true"><SharePoint:MenuItemTemplaterunat="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:MenuItemTemplaterunat="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:MenuItemTemplaterunat="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><!---
--- --- End of Horizontal Top Navigation Bar --- --- ---><!---
--- --- Edit Consoles --- --- ---><asp:ContentPlaceHolderID="WSSDesignConsole"runat="server"><wssuc:DesignModeConsoleid="IdDesignModeConsole"runat="server"/></asp:ContentPlaceHolder><asp:ContentPlaceHolderID="SPNavigation"runat="server"><SharePoint:DelegateControlID="DelegateControl7"runat="server"ControlId="PublishingConsole"PrefixHtml="&lt;tr&gt;&lt;td
colspan=&quot;4&quot; id=&quot;mpdmconsole&quot; class=&quot;ms-consolemptablerow&quot;&gt;"SuffixHtml="&lt;/td&gt;&lt;/tr&gt;"></SharePoint:DelegateControl></asp:ContentPlaceHolder><!---
--- --- End of Edit Consoles --- --- ---><!---
--- --- Page Header --- --- ---><asp:ContentPlaceHolderid="PlaceHolderPageImage"runat="server"/><asp:ContentPlaceHolderid="PlaceHolderTitleLeftBorder"runat="server"/><!---
Breadcrumb ---><asp:ContentPlaceHolderid="PlaceHolderTitleBreadcrumb"runat="server"><asp:SiteMapPathSiteMapProvider="SPContentMapProvider"id="ContentMap"SkipLinkText=""
            

              NodeStyle-CssClass
              ="ms-sitemapdirectional"
              runat
              ="server"
              />
              &nbsp;
              </
              asp:ContentPlaceHolder
              >
              <!---
Page Title - leave wrapped in table cell in order to show on sub pages and hide on
home page -->
              <
              table
              >
              <
              tr
              >
              <
              td
              height=100% valign=topID=onetidPageTitleclass="ms-pagetitle"><h2class="ms-pagetitle"><asp:ContentPlaceHolderid="PlaceHolderPageTitleInTitleArea"runat="server"/></h2></td></tr></table><!--
Mini Console - supplementary buttons for Site Map --><asp:ContentPlaceHolderid="PlaceHolderMiniConsole"runat="server"/><asp:ContentPlaceHolderid="PlaceHolderTitleRightMargin"runat="server"/><asp:ContentPlaceHolderid="PlaceHolderTitleAreaSeparator"runat="server"/><!---
--- --- End of Page Header --- --- ---><!---
--- --- Left Navigation Bar --- --- ---><asp:ContentPlaceHolderid="PlaceHolderLeftNavBarDataSource"runat="server"/><!--
Calendar --><asp:ContentPlaceHolderid="PlaceHolderCalendarNavigator"runat="server"/><asp:ContentPlaceHolderid="PlaceHolderLeftNavBarTop"runat="server"/><!--
Quick Launch --><asp:ContentPlaceHolderid="PlaceHolderLeftNavBar"runat="server"><!--
View All Site Content --><labelclass="ms-hidden"><SharePoint:EncodedLiteralID="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
              >
              <!--
Quick Launch Items -->
              <
              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
              >
              <!---
Tree View --->
              <
              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
              >
              <!--
Recycle Bin -->
              <
              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
              >
              <!---
--- --- End of Left Navigation Bar --- --- --->
              <
              asp:ContentPlaceHolder
              id
              ="PlaceHolderLeftActions"
              runat
              ="server"
              />
              <
              asp:ContentPlaceHolder
              id
              ="PlaceHolderNavSpacer"
              runat
              ="server"
              ><
              IMG
              SRC
              ="/_layouts/images/blank.gif"
            
            

              width=138height=1alt=""></asp:ContentPlaceholder><asp:ContentPlaceHolderid="PlaceHolderLeftNavBarBorder"runat="server"></asp:ContentPlaceHolder><asp:ContentPlaceHolderid="PlaceHolderBodyLeftBorder"runat="server"/><!---
--- --- Page Content --- --- ---><PlaceHolderid="MSO_ContentDiv"runat="server"><tableid="MSO_ContentTable"width=100% height="100%"border="0"cellspacing="0"cellpadding="0"
      class="ms-propertysheet"><tr><tdclass='ms-bodyareaframe'valign="top"height="100%"><Aname="mainContent"></A><asp:ContentPlaceHolderid="PlaceHolderPageDescription"runat="server"/><asp:ContentPlaceHolderid="PlaceHolderMain"runat="server"></asp:ContentPlaceHolder></td></tr></table></PlaceHolder><!---
--- --- End of Page Content --- --- ---><asp:ContentPlaceHolderid="PlaceHolderBodyRightMargin"runat="server"/><asp:ContentPlaceHolderid="PlaceHolderFormDigest"runat="server"><SharePoint:FormDigestID="FormDigest1"runat=server/></asp:ContentPlaceHolder><inputtype="text"name="__spDummyText1"style="display:none;"size=1/><inputtype="text"name="__spDummyText2"style="display:none;"size=1/></form><asp:ContentPlaceHolderid="PlaceHolderUtilityContent"runat="server"/><asp:ContentPlaceHolderid="PlaceHolderBodyAreaClass"runat="server"/><asp:ContentPlaceHolderid="PlaceHolderTitleAreaClass"runat="server"/><!---
--- --- Hidden Placeholders --- --- ---><asp:PanelID="Panel1"visible="false"runat="server"><!--
Place unused Content Placeholders here --></asp:Panel><!---
--- --- End of Hidden Placeholders --- --- ---></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
{ publicclass blank
: System.Web.UI.MasterPage { protectedvoid 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, 
            
            

              C
              ulture=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
{ publicclass customPageLayout
: PublishingLayoutPage { protectedvoid 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" ?><SolutionSolutionId="ENTER_SOLUTION_ID_GUID_HERE"xmlns="http://schemas.microsoft.com/sharepoint/"ResetWebServer="TRUE"><Assemblies><AssemblyDeploymentTarget="GlobalAssemblyCache"Location="MOSSFeatures.dll"><SafeControls><SafeControlSafe="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
              >
              <!--
Page Layouts-->
              <
              TemplateFile
              Location
              ="FEATURES\CustomPublishingLayouts\PageLayouts\customPageLayout.aspx"
              />
              <!--
Master Pages -->
              <
              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

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 ***** 

<TemplateFileLocation="FEATURES\ClientPublishingLayouts\MasterPages\blank.master"/><TemplateFileLocation="FEATURES\ClientPublishingLayouts\MasterPages\client1.master"/> *****
PROVISION ***** <FileUrl="blank.master"Type="GhostableInLibrary"/><FileUrl="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><TemplateName="ClientPublishingLayouts
MasterPages"
         Path="C:\Development\Solution\Project\TEMPLATE\FEATURES\ClientPublishingLayouts\MasterPages"><ItemName="DDF"
         Text="TEMPLATE\FEATURES\ClientPublishingLayouts\MasterPages\FILENAME 


         FEATURES\ClientPublishingLayouts\MasterPages\FILENAME"/><ItemName="MANIFEST"
         Text="&lt;TemplateFile
Location=&quot;

         FEATURES\ClientPublishingLayouts\MasterPages\FILENAME&quot;/&gt;"/><ItemName="PROVISION"
         Text="&lt;File
Url=&quot;FILENAME&quot; 


         Type=&quot;GhostableInLibrary&quot;/&gt;"/></Template><TemplateName="_Layouts\ClientPages\Migration"
         Path="C:\Development\Solution\Project\TEMPLATE\LAYOUTS\ClientPages\Migration"><ItemName="DDF"
         Text="TEMPLATE\LAYOUTS\ClientPages\Migration\FILENAME 


         LAYOUTS\ClientPages\Migration\FILENAME"/><ItemName="MANIFEST"
         Text="&lt;TemplateFile
Location=&quot;

         LAYOUTS\ClientPages\Migration\FILENAME&quot;/&gt;"/></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...

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...

I'm working with a client who needs to migrate content from MCMS2002 to MOSS by NOT using the out-of-box migration tools.  While that's a story worthy of a whole new blog, one of the problems I came across was the need to create publishing pages from scratch using the object model.  It's really not that hard at all - you just need to use some of the features of the new Microsoft.SharePoint.Publishing assembly. 

Here's the code to get it done...

            //get
the current top level site as publishing web so you can get the available page layouts
for the known content type PublishingSite pubSite = new PublishingSite(SPContext.Current.Site); //get
the site content type that contains the page layout you want to use SPContentType
contentType = pubSite.ContentTypes["Custom Page Layout
Content Type"]; //get the page layouts for the
content type PageLayoutCollection pageLayouts = pubSite.GetPageLayouts(contentType, true); //I
like refering to the page layouts by title, so I shove them into a generic dictionary  Dictionary<string,
PageLayout> dPageLayouts = new Dictionary<string,
PageLayout>(); foreach (PageLayout pageLayout in pageLayouts)
{ dPageLayouts.Add(pageLayout.Title, pageLayout); } //get
the page layout you want to use PageLayout pageLayoutToUse = dPageLayouts["layoutName"]; //get
the current publishing web PublishingWeb pubWeb = PublishingWeb.GetPublishingWeb(SPContext.Current.Web); //create
a new publishing page in the web PublishingPage newPubPage = pubWeb.GetPublishingPages().Add("newPageName.aspx",
pageLayoutToUse); //set properties and placeholder content
just like you would if you were adding a new file to a document library SPListItem
newPage = newPubPage.ListItem; newPage["Title"]
= "New Page Title"; newPage["content"]
= "<span><b>here's some new content</b></span>";
newPage.Update(); //check the file in and publish it newPage.File.CheckIn("Checked
in on creation"); newPage.File.Publish("Published
on creation"); try { //this
is a hack that ensures if the site has workflow turned on, the new page will get approved newPage.File.Approve("Approved
on creation"); } catch { //approval
is not enabled } 

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...