I was recently challenged with trying to come up with a least privilege scenario for running a console application or windows service against a SharePoint Farm to perform read-only type operations.  Without the correct permissions there are several exceptions you will run into, including File IO, UnauthorizedAccess, SPException, etc.  A joy to wade through.  :-) 

I used this KB article as a starting point for what we knew would work.  It states that the identity used to run the console application should be the following:

• Farm Administrator
• Read/Write database permissions on the configuration and content databases.
• Site collection administrator
• Permissions to each site in the site collection

I started my quest with no permissions granted on the farm and slowly elevated them until I was able to successfully iterate the object model.  I ended up with close to what is published above but I was showing DBO permissions were required for the database.  After consulting with some people internally I was able to use the SQL Role WSS_Content_Application_Pools for the configuration database, but was still requiring DBO for the content databases.  Again, some help internally brought to my attention that a stored procedure was required to enumerate the sites that exist in the site collection.  I was able to grant execute permissions for the user on the content databases using the following command:

GRANT EXECUTE TO [DOMAIN\username]

I also changed the permissions for the user on the content database to db_datareader.  After the changes were made the console application was able to successfully iterate the content in the site collection in a read-only fashion.  The final permissions were as follows:

• Farm Administrator
• db_datareader permissions on the content databases
• WSS_Content_Application_Pools permissions on the SharePoint_Config (default name) database
• GRANT EXECUTE permission on the stored procs in the content database
• Site collection administrator
• Permissions to each site in the site collection

This could be further reduced to the exact stored procs required in the content databases, but I’ll leave that for another day.  Write permissions don’t seem to be required on the content database as indicated in the KB and we can leverage the SharePoint specific SQL role for the configuration database.  The fact that we can reduce this to db_datareader instead of read / write on the content databases should make some of the DBAs of the world a little happier.

I can’t take credit or this one, but a colleague I have been working with was able to figure this out.  He doesn’t blog, so I am sharing it with the greater community.  Our quest was to upload a document into a document library using the Copy.asmx web service and set the content type on the document as well as other field information as part of the upload.  The method takes a FieldInformation array, so at first glance this seemed like it was going to be pretty easy.  We all know what happens next.

Initial attempts were successful at uploading, but not setting the content type.  The content type would always end up as Document, the default.  We tried several different variations, but nothing worked.  There are also others that seem to have had the same fate and come up with other workarounds.

My colleague had the idea to call the GetItem() method for an item that had the content type already set, and there was the answer.  The type of field for a content type is FieldType.Choice, not FieldType.Text, which was the assumption all along.  Calling GetItem() returned the following:

<FieldInformation Type="Choice" DisplayName="Content Type" InternalName="ContentType" Value="***"/>

From there it was straightforward.  Uploading and setting the content type in one simple method call.  He asked that I give his company a plug, so … those people at SAS are pretty smart aren’t they. :-)

I work in the ISV Practice here at Microsoft.  There are two tools recently released to the SharePoint community that should have ISVs and Enterprise customers excited. 

SPDisposeCheck provides a static source code analysis tool to check for leaks that may be caused by not disposing of SPSite and SPWeb objects properly.  While most people that have worked with SharePoint know of these perils, this tool can provide a second set of eyes on your code.  For those new to the product, SPDisposeCheck will allow you to uncover those instances where improperly disposed objects would result in leaked memory.  Instances where this occurs isn’t always obvious, so the tool can help reduce leaks that make it to production.

Another exciting tool is the SPDiag tool.  This tool greatly simplifies gathering data required for troubleshooting issues in a SharePoint environment.  When working on issues or performance problems getting a good snapshot if the farm environment can help uncover the root cause of the issues quickly and get customers back to work.

The default page size in the US is Letter, 8.5in x 11in.  In other parts of the world A4 (8.3in x 11.7in) is the standard.  Reports in Reporting Services are hard coded as part of the design process.  In order to control the page size in the rendering process we need to pass the proper Device Information Settings to the report at run time.  This will work for physical page oriented renders like PDF, Image, etc.  This is a simple Xml string that can be passed as a parameter to the report in order to control these settings.  Each export type has a different set of properties that can be overridden and controlled in this way.  The Device Info Settings for a PDF document can be found here.

If we are using the Report Viewer control to display the reports we will need to disable the ability to print a report and potentially disable exporting the report, depending on the use cases we want to support.  To still provide this capability to our users we can expose the print and export properties using a link button or other postback capable control.  We can also expose the available print and export formats using a drop down or other mechanism.  Now when the user chooses to print or export the report we can override the process by passing the device info settings for the page height and width when the report is rendered.  In the example below we are exporting to PDF and passing the page height and width to match an A4 paper size as the targeted device (line 66).

   1: private void RenderReportToClient()

   2: {

   3:     //set credentials

   4:     RSExecuteProxy.ReportExecutionService rs = new RSExecuteProxy.ReportExecutionService();

   5:     rs.Credentials = System.Net.CredentialCache.DefaultCredentials;

   6:  

   7:     RSProxy.ReportingService2005 rsInfo = new RSProxy.ReportingService2005();

   8:     rsInfo.Credentials = System.Net.CredentialCache.DefaultCredentials;

   9:  

  10:     // init render args

  11:     byte[] result = null;

  12:     string reportPath = rptViewer.ServerReport.ReportPath;

  13:     string format = "PDF";

  14:     string historyId = null;

  15:  

  16:     string encoding;

  17:     string mimeType;

  18:     string extension;

  19:     RSExecuteProxy.Warning[] warnings = null;

  20:     string[] streamIDs = null;

  21:  

  22:     //init exec info

  23:     RSExecuteProxy.ExecutionInfo execInfo = new RSExecuteProxy.ExecutionInfo();

  24:     RSExecuteProxy.ExecutionHeader execHeader = new RSExecuteProxy.ExecutionHeader();

  25:  

  26:     rs.ExecutionHeaderValue = execHeader;

  27:  

  28:     //get report

  29:     execInfo = rs.LoadReport(reportPath, historyId);

  30:  

  31:     String SessionId = rs.ExecutionHeaderValue.ExecutionID;

  32:  

  33:     //get parameter info

  34:     ReportParameterInfoCollection parameters = rptViewer.ServerReport.GetParameters();

  35:  

  36:     //figure out how many parameters we will have 

  37:     //those with multi-value will need there own ParameterValue in the array

  38:     int paramCount = 0;

  39:  

  40:     foreach (ReportParameterInfo pramInfo in parameters)

  41:     {

  42:         paramCount += pramInfo.Values.Count;

  43:     }

  44:  

  45:  

  46:     RSExecuteProxy.ParameterValue[] prams = new SSRSWeb.RSExecuteProxy.ParameterValue[paramCount];

  47:  

  48:     int currentPramPosition = 0;

  49:  

  50:     //set pram values

  51:     foreach (ReportParameterInfo pramInfo in parameters)

  52:     {

  53:         foreach (string pramValue in pramInfo.Values)

  54:         {

  55:             prams[currentPramPosition] = new SSRSWeb.RSExecuteProxy.ParameterValue();

  56:             prams[currentPramPosition].Label = pramInfo.Name;

  57:             prams[currentPramPosition].Name = pramInfo.Name;

  58:             prams[currentPramPosition].Value = pramValue;

  59:             currentPramPosition++;

  60:         }

  61:     }

  62:  

  63:     rs.SetExecutionParameters(prams, "en-US");

  64:  

  65:     //build the device settings  (A4 8.3 × 11.7)

  66:     string deviceInfo = string.Format("<DeviceInfo><PageHeight>{0}</PageHeight><PageWidth>{1}</PageWidth></DeviceInfo>", "11.7in", "8.3in");

  67:  

  68:     //get report bytes

  69:     result = rs.Render(format, deviceInfo, out extension, out encoding, out mimeType, out warnings, out streamIDs);

  70:  

  71:     Response.ClearContent();

  72:     Response.AppendHeader("Content-Disposition", "inline;filename=report.pdf");

  73:     Response.AppendHeader("content-length", result.Length.ToString());

  74:     Response.ContentType = "application/pdf";

  75:     Response.BinaryWrite(result);

  76:     Response.Flush();

  77:     Response.Close();

  78: }

When the report is saved you can view the PDF and examine the properties and notice that the page height and width is 8.3in x 11.7in as specified.

Recently we were involved in a conversation around upgrading from SSRS 2005 to SSRS 2008.  The credit for this post goes to Robert Bruckner who guided us during the internal discussion.  When you move from SSRS 2005 to SSRS 2008 there are things that happen internally that may be unknown to you.   If you upload or deploy your SSRS 2005 reports to an SSRS 2008 server an attempt is made to upgrade the schema to SSRS 2008 RDL.  Should that upgrade fail, the report is flagged and an attempt to upgrade will not be made on that report again.  The report can still be run by a user, but it will leverage the 2005 processing engine.

If the upgrade is successful we store the original report definition in the database so that you can get to the definition as it existed when deployed.  A call to the GetReportDefinition() method or clicking the 'edit' link in Report Manager will return the original RDL file.  The upgraded version of the report is stored as a compiled version as a 2008 report in the 2008 RDL.  This allows reporting services to leverage this report for rendering when a request is made by the user.  It also allows the report to take advantage of the SSRS 2008 features such as on-demand processing.

If you want to upgrade the report prior to uploading to SSRS you will need to open it in Visual Studio 2008 (BIDS) or Report Builder v2, although that capability was not available in the RC1 release.  If you would like to figure out which engine is being used to process your report you can leverage the ExecutionLog2 view in the reporting services database.  There is a column called AdditionalInfo that has a <ProcessingEngine> element.  If that element is set to 2 it means that the 2008 processing engine was used, if set to 1 your report is using the 2005 processing engine.

The SharePoint Threaded Discussion is a forum type of post.  Underneath, like all things SharePoint, it is a list.  By default that list is made up of two content types, Discussion and Message.  The content types have IDs of 0x012002 and 0x0107 respectively.  Following the content type inheritance chain this means that the Discussion content type inherits from folder and the Message content type from Item.  This gives us some clue about the structure of the list.

If you enter a top level item in a threaded discussion list it will be created as a folder.  In order to navigate each top level thread using the object model we use code similar to that shown below.

using ( SPSite siteCollection = new SPSite( "http://moss.litwareinc.com/" ) ) {
    using ( SPWeb web = siteCollection.OpenWeb( "/SiteDirectory/mktg" ) ) {
        SPList list = web.Lists["Team Discussion"];

        foreach ( SPListItem folder in list.Folders ) {
            Console.WriteLine( "-- Folder --" );
            Console.WriteLine( folder.Title );
            Console.WriteLine( folder.UniqueId.ToString() );
            Console.WriteLine( folder.ID.ToString() );
            Console.WriteLine( folder.Xml );
            Console.WriteLine( "-- End Folder --" );
        }
    }
}

You can also iterate over the list items themselves using the typical foreach convention.  When you do this take a look at the Xml property for the List Item and you will see various items that we can use to find the context of our item within the threaded discussion.

<?xml version="1.0" encoding="utf-8" ?>
<z:row xmlns:z='#RowsetSchema' 
       ows_ContentTypeId='0x010700135BC7419F95B04C8EA15325163C1444' 
       ows_Body='&lt;div class=ExternalClassAAF51B42E3834F8D90CA3A8DA7739064&gt;&lt;div&gt;second sample item&lt;br&gt;&lt;br&gt;&lt;hr&gt;&lt;b&gt;From: &lt;/b&gt;System Account&lt;br&gt;&lt;b&gt;Posted: &lt;/b&gt;Wednesday, June 04, 2008 5:14 PM&lt;br&gt;&lt;b&gt;Subject: &lt;/b&gt;sample item one&lt;br&gt;&lt;br&gt;&lt;div class=ExternalClassF19C451E2C284124AB09D103E8A70A18&gt;&lt;div&gt;first sample item&lt;/div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/div&gt;' 
       ows_TrimmedBody='&lt;div class=ExternalClass4D66DF23C3C649C4985CFE81A1E2E0E2&gt;&lt;div&gt;second sample item&lt;br&gt;&lt;/div&gt;&lt;/div&gt;' 
       ows_ParentFolderId='1' 
       ows_ID='2' 
       ows_ContentType='Message' 
       ows_Modified='2008-06-04 17:14:33' 
       ows_Created='2008-06-04 17:14:33' 
       ows_Author='1073741823;#System Account' 
       ows_Editor='1073741823;#System Account' 
       ows_owshiddenversion='1' 
       ows_WorkflowVersion='1'
       ows__UIVersion='512' 
       ows__UIVersionString='1.0' 
       ows_Attachments='0' 
       ows__ModerationStatus='0' 
       ows_SelectTitle='2' 
       ows_Order='200.000000000000' 
       ows_GUID='{8FAC9A20-6343-48A3-8BE3-CD7E17E45894}' 
       ows_FileRef='2;#SiteDirectory/mktg/Lists/TeamDiscussion/sample item one/2_.000' 
       ows_FileDirRef='2;#SiteDirectory/mktg/Lists/Team Discussion/sample item one' 
       ows_Last_x0020_Modified='2;#2008-06-04 17:14:33'
       ows_Created_x0020_Date='2;#2008-06-04 17:14:33' 
       ows_FSObjType='2;#0' 
       ows_PermMask='0x7fffffffffffffff' 
       ows_FileLeafRef='2;#2_.000' 
       ows_UniqueId='2;#{87C5CD04-7D68-4B26-B00C-DD76AE7B96D8}' 
       ows_ProgId='2;#' 
       ows_ScopeId='2;#{6ED2F3B8-3D0A-4B4F-B092-C9A6D1942AE2}' 
       ows__EditMenuTableStart='2_.000' 
       ows__EditMenuTableEnd='2'
       ows_LinkFilenameNoMenu='2_.000' 
       ows_LinkFilename='2_.000' 
       ows_ServerUrl='/SiteDirectory/mktg/Lists/Team Discussion/sample item one/2_.000' 
       ows_EncodedAbsUrl='http://moss.litwareinc.com/SiteDirectory/mktg/Lists/Team%20Discussion/sample%20item%20one/2_.000' 
       ows_BaseName='2_' 
       ows_MetaInfo='2;#' 
       ows__Level='1' 
       ows__IsCurrentVersion='1' 
       ows_ThreadIndex='0x01CA94B8313E972C16929A454ACFA141B2588F7291DB000004B927' 
       ows_ShortestThreadIndexIdLookup='1;#' 
       ows_DiscussionTitleLookup='1;#sample item one' 
       ows_DiscussionTitle='sample item one' 
       ows_ReplyNoGif='SiteDirectory/mktg/Lists/Team Discussion/sample item one' 
       ows_ThreadingControls='0x01CA94B8313E972C16929A454ACFA141B2588F7291DB000004B927' 
       ows_IndentLevel='0x01CA94B8313E972C16929A454ACFA141B2588F7291DB000004B927' 
       ows_Indentation='0x01CA94B8313E972C16929A454ACFA141B2588F7291DB000004B927' 
       ows_StatusBar='2008-06-05T00:14:33Z' 
       ows_BodyAndMore='&lt;div class=ExternalClassAAF51B42E3834F8D90CA3A8DA7739064&gt;&lt;div&gt;second sample item&lt;br&gt;&lt;br&gt;&lt;hr&gt;&lt;b&gt;From: &lt;/b&gt;System Account&lt;br&gt;&lt;b&gt;Posted: &lt;/b&gt;Wednesday, June 04, 2008 5:14 PM&lt;br&gt;&lt;b&gt;Subject: &lt;/b&gt;sample item one&lt;br&gt;&lt;br&gt;&lt;div class=ExternalClassF19C451E2C284124AB09D103E8A70A18&gt;&lt;div&gt;first sample item&lt;/div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/div&gt;' 
       ows_MessageBody='&lt;div class=ExternalClassAAF51B42E3834F8D90CA3A8DA7739064&gt;&lt;div&gt;second sample item&lt;br&gt;&lt;br&gt;&lt;hr&gt;&lt;b&gt;From: &lt;/b&gt;System Account&lt;br&gt;&lt;b&gt;Posted: &lt;/b&gt;Wednesday, June 04, 2008 5:14 PM&lt;br&gt;&lt;b&gt;Subject: &lt;/b&gt;sample item one&lt;br&gt;&lt;br&gt;&lt;div class=ExternalClassF19C451E2C284124AB09D103E8A70A18&gt;&lt;div&gt;first sample item&lt;/div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/div&gt;' 
       ows_BodyWasExpanded='{8FAC9A20-6343-48A3-8BE3-CD7E17E45894}' 
       ows_QuotedTextWasExpanded='{8FAC9A20-6343-48A3-8BE3-CD7E17E45894}' 
       ows_CorrectBodyToShow='&lt;div class=ExternalClass4D66DF23C3C649C4985CFE81A1E2E0E2&gt;&lt;div&gt;second sample item&lt;br&gt;&lt;/div&gt;&lt;/div&gt;' ows_FullBody='&lt;div class=ExternalClassAAF51B42E3834F8D90CA3A8DA7739064&gt;&lt;div&gt;second sample item&lt;br&gt;&lt;br&gt;&lt;hr&gt;&lt;b&gt;From: &lt;/b&gt;System Account&lt;br&gt;&lt;b&gt;Posted: &lt;/b&gt;Wednesday, June 04, 2008 5:14 PM&lt;br&gt;&lt;b&gt;Subject: &lt;/b&gt;sample item one&lt;br&gt;&lt;br&gt;&lt;div class=ExternalClassF19C451E2C284124AB09D103E8A70A18&gt;&lt;div&gt;first sample item&lt;/div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/div&gt;' 
       ows_LimitedBody='&lt;div class=ExternalClassAAF51B42E3834F8D90CA3A8DA7739064&gt;&lt;div&gt;second sample item&lt;br&gt;&lt;br&gt;&lt;hr&gt;&lt;b&gt;From: &lt;/b&gt;System Account&lt;br&gt;&lt;b&gt;Posted: &lt;/b&gt;Wednesday, June 04, 2008 5:14 PM&lt;br&gt;&lt;b&gt;Subject: &lt;/b&gt;sample item one&lt;br&gt;&lt;br&gt;&lt;div class=ExternalClassF19C451E2C284124AB09D103E8A70A18&gt;&lt;div&gt;first sample item&lt;/div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/div&gt;' 
       ows_MoreLink='2' 
       ows_LessLink='2' 
       ows_ToggleQuotedText='2' 
       ows_Threading='0x01CA94B8313E972C16929A454ACFA141B2588F7291DB000004B927' 
       ows_PersonImage='System Account' 
       ows_PersonViewMinimal='System Account' 
       ows_IsRootPost='0' 
       ows_ItemChildCount='2;#0' 
       ows_ServerRedirected='0'/>

One of the more important properties is the ows_ParentFolderId.  By leveraging this property we can establish the parent thread or discussion, in this case the folder, that is the host for the item.  This will always be the top level folder item, not the item that was responded to originally.  While this does allow you to figure out which items go with which folder, it does not provide order or hierarchy.

If you examine the default 'Threaded' view that comes with an instance of the Team Discussion you will notice that it contains one column, 'Threading (threaded)'.  This column is used for display and also used to sort the items.  There is a group of properties that provide a structure that enabling you to figure out he thread hierarchy.  Notice the ows_ThreadIndex, ows_Threading, ows_ThreadingControls, ows_IndentLevel, etc.  These properties all have the same value for an item, but as you navigate from item to item notice that a hierarchy of sorts is formed.  The base item has a thread value and then the children have this same thread value, but with some additional random text after the base item.  This begins to form a hierarchy. 

ows_ThreadingIndex='0x01CA94B8313E972C16929A454ACFA141B2588F7291DB’

|_ows_ThreadingIndex='0x01CA94B8313E972C16929A454ACFA141B2588F7291DB000004B927'

                |_ows_ThreadingIndex='0x01CA94B8313E972C16929A454ACFA141B2588F7291DB000004B9270000026E29'

When reviewing the Xml attributes another item looks promising, ows_Order.  It has a format of xxx.xxxxxx.  This leads one to believe that this would control the order of the items in the thread.  I was hoping to find a pattern that was parent.childorder or something to that affect, but that is not the case.  Upon further examination this is simply the item id.  It is probably reserved for some future use.

One of the new features available in SharePoint 2007 are content types.  Content types allow you to classify content to be a particular type.  By marking content as a particular content type the metadata, workflow and policies associated with that content type are leveraged instead of default policies that may apply to a standard document.  One of the content types available is called 'Link to a Document'.  This content type allows you to store a link to a document in a document library instead of the document itself.  This comes in handy for documents that are stored in an http(s) referenceable location.  When an item is added to a document library and it is classified as a 'Link to a Document' content type an .aspx page is created and stored in the document library as a file.  This page is used to redirect the opening of the file to the location where the document link actually resides.  The content of the .aspx file is shown below.

<%@ Assembly Name='Microsoft.SharePoint, Version=12.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c' %>
<%@ Register TagPrefix='SharePoint' Namespace='Microsoft.SharePoint.WebControls' Assembly='Microsoft.SharePoint' %>
<%@ Import Namespace='System.IO' %>
<%@ Import Namespace='Microsoft.SharePoint' %>
<%@ Import Namespace='Microsoft.SharePoint.Utilities' %>
<%@ Import Namespace='Microsoft.SharePoint.WebControls' %>

<html xmlns:mso="urn:schemas-microsoft-com:office:office" xmlns:msdt="uuid:C2F41010-65B3-11d1-A29F-00AA00C14882">
<Head> <META Name='progid' Content='SharePoint.Link'>
<!--[if gte mso 9]><xml>
<mso:CustomDocumentProperties>
<mso:URL msdt:dt="string">http://moss.litwareinc.com/docs/my.xls, http://moss.litwareinc.com/docs/my.xls</mso:URL>
<mso:ContentType msdt:dt="string">Link to a Document</mso:ContentType>
</mso:CustomDocumentProperties>
</xml><![endif]-->
</head>
    <body>
        <form id='Form1' runat='server'>
            <SharePoint:UrlRedirector id='Redirector1' runat='server' />
        </form>
    </body>
</html>

If you want to create a 'Link to a Document' item programmatically, you can duplicate this file and replace the following string with the Url that matches the document where you want the item linked.

<mso:URL msdt:dt="string">http://moss.litwareinc.com/docs/my.xls, http://moss.litwareinc.com/docs/my.xls</mso:URL>

Create a template .txt file for this with the code below so that you can easily replace the url with your content link.  Notice the reference to {0}, {0}.  This will be used as a string replacement placeholder in the code snippet that will create the item in the document library.  In this example I have saved the file locally to the c: drive as linktodocumenttemplate.txt.

<%@ Assembly Name='Microsoft.SharePoint, Version=12.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c' %>
<%@ Register TagPrefix='SharePoint' Namespace='Microsoft.SharePoint.WebControls' Assembly='Microsoft.SharePoint' %>
<%@ Import Namespace='System.IO' %>
<%@ Import Namespace='Microsoft.SharePoint' %>
<%@ Import Namespace='Microsoft.SharePoint.Utilities' %>
<%@ Import Namespace='Microsoft.SharePoint.WebControls' %>

<html xmlns:mso="urn:schemas-microsoft-com:office:office" xmlns:msdt="uuid:C2F41010-65B3-11d1-A29F-00AA00C14882">
<Head> <META Name='progid' Content='SharePoint.Link'>
<!--[if gte mso 9]><xml>
<mso:CustomDocumentProperties>
<mso:URL msdt:dt="string">{0}, {0}</mso:URL>
<mso:ContentType msdt:dt="string">Link to a Document</mso:ContentType>
</mso:CustomDocumentProperties>
</xml><![endif]-->
</head>
    <body>
        <form id='Form1' runat='server'>
            <SharePoint:UrlRedirector id='Redirector1' runat='server' />
        </form>
    </body>
</html>

Once you have that file in place the following code snippet can be used to create the item in the document library.

using ( SPSite siteCollection = new SPSite( "http://moss.litwareinc.com" ) ) {
    using ( SPWeb web = siteCollection.OpenWeb( "docs" ) ) {
        SPList list = web.Lists["Sample"];

        //link to the file
        string fileLinkUrl = "http://moss.litwareinc.com/docs/Shared%20Documents/ConfigureIRMinWSS30.doc";

        StringBuilder builder = new StringBuilder();

        using ( TextReader reader = new StreamReader( @"C:\linktodocumenttemplate.txt" ) ) {
            builder.Append( reader.ReadToEnd() );
        }

        //replace string template with values
        builder.Replace( "{0}", fileLinkUrl );
        
        //should change the name of the .aspx file per item
        SPFile file = list.RootFolder.Files.Add( "link_title.aspx", UTF8Encoding.UTF8.GetBytes(builder.ToString()));

        //set list item properties
        SPListItem item = file.Item;
        item["Content Type"] = "Link to a Document";
        SPFieldUrlValue itemUrl = new SPFieldUrlValue();
        itemUrl.Description = "From sample code";
        itemUrl.Url = fileLinkUrl;
        item["URL"] = itemUrl;
        //persist changes
        item.Update();
    }
}

Since my first post was based on removing web parts from the web part gallery of a 'My Site' there have been questions about how to add the web parts back should circumstances require it.  This is pretty straight-forward, but can get more interesting depending on how robust you want to make the end solution.  The Web Part Gallery is a document library that holds a reference to a web part file, either a .dwp or .webpart file.  This file is simply a metadata definition of the web part.  To add a web part back in the gallery we can leverage the code shown below.  This assumes that the web part assembly is installed and the safe control entries are made in the web.config file.

public static void IterateWebPartGallery(string siteCollectionUrl) {
    string filePath = @"C:\Program Files\Common Files\Microsoft Shared\web server extensions\12\TEMPLATE\FEATURES\PortalLayouts\DWP\owa.dwp";

    using ( SPSite site = new SPSite( siteCollectionUrl ) ) {
        using ( SPWeb web = site.OpenWeb() ) {

            SPList webPartGallery = web.GetCatalog( SPListTemplateType.WebPartCatalog );

            SPFolder folder = webPartGallery.RootFolder;
            if( folder != null ) {
                byte [] webPartFile = File.ReadAllBytes(filePath);
                FileInfo webPartFileInfo = new FileInfo(filePath);

                folder.Files.Add(webPartFileInfo.Name, webPartFile);
                folder.Update();
            }
        }
    }
}

The code gets a reference to the web part gallery in the target site collection by calling the SPWeb.GetCatalog() method.  Once we have that reference we get a reference to the root folder of the gallery and call the folder.Files.Add() method to add the web part file.  Calling folder.Update() persists this information to the database.

While this will simply add the file by parsing its contents it won't give us the fine grained control we may want for adding our web part to the gallery.  If the file uses resources to define the title and description properties then those get loaded into the gallery "as is" using the method above.  This makes our title $Resources:spscore,PeopleWebParts_OWA_Title_Text; and the description $Resources:spscore,PeopleWebParts_OWA_Desc_Text;.

This can be made a bit more robust by figuring out the title and description from the resource file and setting them in the gallery when the web part is loaded.  The SPFolder.Files.Add() method has an overload that accepts a Hashtable reference where we can set additional properties for the web part.  The resource values above indicate the resource file is the spscore resource file, spscore.en-US.resx for the en-US culture.  Resource files in SharePoint are stored in the \12\Resources directory.  I tried to load this file directly using the ResXResourceReader, but received an exception about a missing 'resheader' value in the file.  Since .resx files are just Xml I decided to use an XPathNavigator and parse the values out that way.  You could also dynamically parse the .webpart or .dwp file to figure out what the associated resx file the web part is referencing, but that is beyond the scope of this post.  The final code snippet is shown below.

string filePath = @"C:\Program Files\Common Files\Microsoft Shared\web server extensions\12\TEMPLATE\FEATURES\PortalLayouts\DWP\owa.dwp";
string resourceDirectory = @"C:\Program Files\Common Files\Microsoft Shared\web server extensions\12\Resources";

using ( SPSite site = new SPSite( siteCollectionUrl ) ) {
    using ( SPWeb web = site.OpenWeb() ) {

        SPList webPartGallery = web.GetCatalog( SPListTemplateType.WebPartCatalog );

        string title = "";
        string description = "";

        XPathDocument xml = new XPathDocument( File.Open( Path.Combine( resourceDirectory, "spscore.en-US.resx" ), FileMode.Open, FileAccess.Read ) );
        XPathNavigator navigator = xml.CreateNavigator();
        string xpathExpression = "/root/Data[@Name='{0}']/Value";
        XPathNavigator node = navigator.SelectSingleNode( string.Format( xpathExpression, "PeopleWebParts_OWA_Title_Text" ) );
        if ( node != null ) {
            title = node.Value;
        }
        node = navigator.SelectSingleNode( string.Format( xpathExpression, "PeopleWebParts_OWA_Desc_Text" ) );
        if ( node != null ) {
            description = node.Value;
        }


        SPFolder folder = webPartGallery.RootFolder;
        if ( folder != null ) {
            byte[] webPartFile = File.ReadAllBytes( filePath );
            FileInfo webPartFileInfo = new FileInfo( filePath );

            Hashtable properties = new Hashtable();
            properties.Add( "Title", title );
            properties.Add( "WebPartDescription", description );
            properties.Add( "Group", "Outlook Web Access" );


            folder.Files.Add( webPartFileInfo.Name, webPartFile, properties );
            folder.Update();
        }
    }
}