If you aren’t familiar with Colligo, it’s a desktop client application/outlook add-in/explorer file manager, that enables users to save documents or emails directly to SharePoint, and be prompted for metadata at the time of saving.

Colligo reads the content type of the target lists/libraries, and generates a default form very similar to what SharePoint does with the default EditForm.aspx ListForm web part. If you don’t like the default form, or need to customize the metadata entry experience (for example custom validation, pulling from external data sources, inter-dependent controls), you can develop a custom editor and show your own Windows Forms-based form to the user.

The default Colligo Editor form, shown here when adding a new Announcement.

How to Start

To start developing a custom editor, begin by installing Colligo Contributor, and obtaining your product and sdk keys from Colligo.

Create a new Visual Studio Class Library project, and add a reference to the Colligo dlls in the GAC.

Add the necessary using statements:

using Colligo;

using Colligo.Properties;

using Colligo.Util;

using Colligo.WML.MetaData;

Change your class to inherit from the ICustomEditor class:

namespace MyNamespace

{

    public class MyCustomEditor : ICustomEditor

    {

    }

}

Implement the Interface methods:

namespace MyNamespace

{

    public class MyCustomEditor : ICustomEditor

    {

        // SDK Key

        private const string SDK_KEY = "XXXXX-XXXXX-XXXXX-XXXXX-XXXXX";

        #region ICustomEditor Members

        public string GetSdkKey()

        {

            return SDK_KEY;

        }

        public EditorResult ShowEditor(IEditContext context)

        {

            // Show your form here

        }

        public ResolveConflictResult ShowResolveConflictDialog(IResolveConflictContext context)

        {

            return ResolveConflictResult.UseDefaultResolveDialog;

        }

        #endregion

    }

}

In the ShowEditor method, this is where you can create an instance of a Windows Form, and call the ShowDialog method on it. You can also pre-validate and avoid showing your form for situations that are not appropriate.

public EditorResult ShowEditor(IEditContext context)

{

    // Check if this is something we care about

    if (!context.List.IsDocumentLibrary)

    {

        return EditorResult.UseDefaultEditor;

    }

    if (!string.Equals(context.List.Name, "Private Documents", StringComparison.CurrentCultureIgnoreCase) &&

        !string.Equals(context.List.Name, "Public Documents", StringComparison.CurrentCultureIgnoreCase))

    {

        return EditorResult.UseDefaultEditor;

    }

    // Only show for Create/Edit (use the default Colligo form for Viewing)

    if (context.EditorMode == EditorMode.Create || context.EditorMode == EditorMode.Edit)

    {

        using (myCustomWindowsForm myForm = new myCustomWindowsForm(context))

        {

            DialogResult createResult = DialogResult.None;

            createResult = myForm.ShowDialog(context.Parent);

            switch (createResult)

            {

                case DialogResult.Cancel:

                    return EditorResult.Cancel;

                case DialogResult.OK:

                    return EditorResult.OK;

                case DialogResult.No:

                    return EditorResult.UseDefaultEditor;

            }

        }

    }

    else

    {

        // View - Show the default editor

        return EditorResult.UseDefaultEditor;

    }

    // Fall through

    return EditorResult.OK;

}

Notice I am passing in the IEditContext instance into my form’s constructor. The IEditContext object has all the goodies in it, and will give you access to the list, the web, the content types, list item metadata, etc.).

What to Consider

Some basic things to consider are:

• Which scenarios will your editor cover? View, Create, Edit?
• Is this only for documents, or list items, or both?
• Will you support content types? A list/library can be configured with multiple content types, which you will need to create a UI for selecting/changing if you decide to support that.
• How will you handle multiple files? Will you enable setting different data for each item, or will you force all items to use the same entered metadata? Think carefully about the “Name” field for documents in document libraries. You want to make sure that the same name is not used for multiple documents.
• Will you allow changing folders (for document libraries with folders enabled)? If so, you’ll need to build this UI.

There are a number of ways/methods that may kick off the display of your form, and you need to consider each of these:

• User selects New > Item from within Colligo Contributor
• This is similar to the New > [Content Type] menu directly in SharePoint. You can expect that EditorContext.ContentType and EditorContext.ListItems[0].ContentType will not be null.
• User selects Upload from within Colligo Contributor
• This is similar to Upload Document from within SharePoint. EditorContext.ContentType and EditorContext.ListItems[0].ContentType may be null.
• User drags/drops a single file onto Colligo Contributor
• EditorContext.ContentType and EditorContext.ListItems[0].ContentType may be null.
• User drags/drops multiple files onto Colligo Contributor
• EditorContext.ContentType and EditorContext.ListItems[0].ContentType may be null.
• User performs a single File > Save As from within an application
• EditorContext.ContentType and EditorContext.ListItems[0].ContentType may be null.
• User drags/drops multiple files onto the Colligo area in Windows Explorer
• EditorContext.ContentType and EditorContext.ListItems[0].ContentType may be null.
• User selects Edit Properties from within Colligo Contributor
• Need to grab existing values and prepopulate your controls. EditorContext.ContentType and EditorContext.ListItems[0].ContentType will not be null.

Some Gotchas

Following are some gotchas to be aware of:

Check for Null

Don’t make any assumptions about any of the items in the IEditContext object. ContentTypes may be null, Fields may not exist or be null, other relevant ILists in the Web may not be synchronized locally, and will be null, etc., etc., etc. Check everything for null first, and test everything that returns a collection/array for Count and Length > 0. If there are fields/lists/lookup column values that your form expects, check for the existence of these things right away, and exit if you don’t find them.

Parent Windows

If your form is called via the Save As dialog from an application (or via the FileManager), the ParentWindow handle may not be valid, so be careful with the ShowDialog(IWin32Window) overload, which threw a System.ComponentModel.Win32Exception for me. I had to wrap my ShowDialog(context.Parent) in a try>catch, and then try it without any parameters (ShowDialog() ).

Custom Field Types

If you are using any custom field types, be really careful to make sure and store the data in the proper format. My customer was using a couple of custom field types found on CodePlex, and one of them extended the Lookup field, and it took me a few traces with Fiddler to figure out that it wanted its values in lookup column format (“52;#ItemName”);

Site Lookup Columns

If you have any lookup columns that are defined in higher-level sites, and you are using those site columns in lists located in subsites, then Colligo will not be able to see the lookup values. In order to implement these scenarios, you will have to force your users to synchronize the higher level sites as well as the subsites.

I had one particular scenario where I couldn’t pre-filter the items in the collection with an SPQuery object (too complicated a query for CAML), so I needed a way to filter the SPListItemCollection afterwards using C#, before returning the XML.

The SPListItemCollection offers the .Delete() and .DeleteItemById() methods, however they will commit the deletion back to SharePoint. I wanted to simply remove some items from the in-memory collection, not delete the items from the server. There was no way that I could see to remove items from an SPListItemCollection in memory only.

I looked into sub-classing or extending the SPListItemCollection class, but there is no public constructor in the base class, and no way to get at the logic behind the .Xml property without nasty reflection.

I ultimately ended up resorting to using Linq to XML to delete the rows directly from the returned XML, and then adjusted the ItemCount accordingly.

Here’s the code:

// Get the list items from a list

SPListItemCollection items = myList.GetItems(mySPQuery);

// Get the xml of the list items

itemXml = surveyItems.Xml;

XNamespace z = "#RowsetSchema";

XDocument xdoc = XDocument.Parse(itemXml);

IEnumerable<XElement> rows = xdoc.Root.Descendants(z + "row");

List<XElement> rowsToDelete = new List<XElement>();

foreach (XElement row in rows)

{

    // Here is where you can test for a condition, and decide to remove a row

    if (row.Attribute("ows_Title").Value.Contains("Some string to filter on"))

    {

        rowsToDelete.Add(row);

    }

}

while (rowsToDelete.Count > 0)

{

    // Update the parent row count

    int rowCount = Convert.ToInt32(rowsToDelete[0].Parent.Attribute("ItemCount").Value);

    rowsToDelete[0].Parent.Attribute("ItemCount").Value = (rowCount - 1).ToString();

    rowsToDelete[0].Remove();

    rowsToDelete.RemoveAt(0);

}

// Get the newly filtered xml

itemXml = xdoc.ToString()

Windows Azure Improvements since last year:

SQL Azure Improvements since last year:

1. Not just RESTful consumption of services anymore
2. Works with standard TDS based tools (SQL management studio)

Microsoft has a vision of "Three screens and a Cloud".

The screens include:

1. Mobile devices
2. Desktop computers
3. Internet connected TVs

   They can all be united by data and services in the cloud.

Public Data in the Cloud (Codename "Dallas").

Repository for public data sets that can be consumed in any number of ways (and easily by Azure)

Accessed through Microsoft PinPoint

Sign up for a CTP key

Some data includes NASA mars photos, GIS data, AP News articles

PinPoint:

Centralized marketplace for partner providers, Azure ISVs and implementers, and gateway to "Dallas" public Data.

"System Center" will plugin to Azure to monitor your Azure instances, check to meet SLAs, and enable you to scale up the Azure instances directly.

2010 will include ability to have the Azure cloud be able to establish a network connection to on-premise resources (i.e. self hosted SQL Server)

WordPress is moving to Windows Azure

I’m implementing the AKS for a customer, and I’m having a hard time understanding how this product actually made it to a public release. It feels like a product that is half finished, that was used as a springboard to creating a commercial product, while leaving the original free version to the wayside. If you are considering working with this, you might want to read about the frustrations I encountered below:

Installation experience – Where are those .bat files?

When you download the AKS, you’ll get a zip file, which contains a folder and a single EXE installer.

Running the installer will perform the following tasks:

1. Installs control adapters and reference files into an AKS folder in your Program Files directory.
2. Copies a feature and master pages/css styles to the /12/Templates/Features folder in your SharePoint installation (if you are running 32 bit).
3. Creates a Start Menu icon group for AKS tasks and links.

After running through the installer, a quick look at the “Welcome to the Accessibility Kit…” PDF informs you that you need to install and activate the feature:

The AKS Feature
The AKS Feature is not the AKS Kit but a part of the Kit that works as a feature in MOSS. The AKS
Feature installs the Example Master pages and the Modified CSS. You must install this by
selecting Install AKS Feature from the Start Menu:  Start | All Programs | AKS by HiSoftware |
AKS Feature install.  Once the feature is installed, you will still need to activate it within your
SharePoint application through: Site Settings | Site Collection Features. Please note if you are
on a 64 Bit server please follow the 64 Bit instructions.

I looked all over for those “64 bit instructions”, but there was nothing. There was a “64bit Feature Install” icon in the Start Menu, but no text anywhere instructing me to click on it.

I figured out that to install the feature, you need to click on either the 64bit Feature Install icon or the AKS Feature Install icon in the Start menu (note that the shortcuts are only created for the current user, and there is no way to tell the installer to install for everyone). If you run these shortcuts from the Start menu, the command window will flash, execute, and then immediately disappear, before you can check if it finished successfully or not. On a 64 bit server, you’ll see a flash of xcopy commands that copy styles and master pages into the /12 folders.

I wanted to be sure that it installed, so I tried to find the location of the batch file so I could run it again in a command prompt and actually see the result. I right-clicked the shortcut and went to Properties to figure out the target location, and it was greyed out:

I looked for the bat file in the Program Files directory, but no luck. Yuck! A .bat file that I can’t see or easily get to?

I figured out that it installed, because I then saw the feature in my Site Collection Features page. I activated it, and then tried to take a look at the master pages and styles.

Control Adapters – Incorrect C#

The AKS comes with several control adapters that rewrite some of the out-of-box control html to make it more compliant. Some of the C# adapter files have mistakes in the C# code that make them not able to compile. For example, in the Web Part Zone Smart Adapter for WCAG2.0, there is an extra curly brace, and even a reference to a variable that is not even declared in the file anywhere:

   1: else

   2: {

   3:

   4:     } // <-- Extra brace?

   5:

   6:     //Output sOutputBuilder to be rendered

   7:     oOutput.Write(sOutputBuilder.ToString()); // <-- sOutputBuilder is never declared in this file!

   8: }

“Smart Adapters” (not too bright)

The AKS comes with several “Smart” control adapters (adapters that do not need a lot of configuration). The Web Part Zone Smart Adapter sounded like it had some promise, as it would convert a web part zone to use divs instead of tables.

However, when you install it, it has the side effect of not rendering any of your web part’s “Titles”. If you want to use the headers that come with the web parts, then this control will not work for you. It also prevented viewing web parts in Design mode, they would just disappear from the page.

Finally, it was hard to see the point of using the adapters at all, as all they appeared to do was add some labels to blogs, wikis, and search boxes. They will certainly not do anything at all if you use the CKS EBE or Wiki versions, or if you have customized/branded the search controls.

Master pages and styles do not exist!

Once you install the feature, a set of master pages and css styles will get installed to the master page and style library galleries for your site collection. I cracked open SharePoint designer, tried to open a master page, and got a nasty error message that the file did not exist and could not be opened.

In order to open the file, I had to run through the SharePoint UI, and “Publish” each master page and CSS style before I could access it via SharePoint designer. There was no mention of this anywhere in the documentation.

Relative font sizes? Good luck!

The AKS stylesheets attempt to change all SharePoint font size declarations into relative sizes in ems, rather than fixed pixel/point sizes. This might work fine for anonymous internet site pages, but if you will ever let your visitors view any of the system pages like list new/edit/upload pages or use out-of-box web parts, good luck tweaking styles for a month to get things right.

Woops, what about default.master?

The AKS installs alternate versions of the out-of-box publishing master pages, such as BlueBand.master, BlackBand.master, etc. I don’t know about you, but none of my customers have ever started from those master pages on internet sites, and all my intranet applications make heavy use of default.master. I was really disappointed to see that there was no alternate version of default.master.

HCCE – Nothing but trouble

The HiSoftware Code Compliance Kit (HCCE) is a SharePoint event handler that will look for a certain string of text in your SharePoint web pages, and replace it with different (possibly more accessible) text. You use a text file in which you specify pipe-delimited lines of text to find and replace (e.g. “Text to find|Text to replace with”). The HCCE has the following problems when implemented:

• There is only a debug build provided (no release version).
• There is no source code (you cannot recompile).
• There is no regex option for pattern matching. All strings must be matched and replaced exactly.
• The DLL looks for a hard-coded path to the configuration text file in C:\Program Files\HiSoftware… This doesn’t work on 64bit systems because the installer installs to Program Files (x86). Since you can’t recompile the DLL, your only option is to copy the text file to the Program Files directory.
• Once you implement the feature, your SharePoint Welcome menu will get rendered above the <html> tag, causing it to appear at the top of your screen and out of place. Several posts about this, and no response at all from HiSoftware.
• The install/uninstall .bat files do not work, and need to be adjusted for 64bit machines. Why no WSP?

Conclusion

Poorly documented, sloppily put together, and full of holes and mistakes, I was very disappointed in the AKS. Coupled with a total lack of support and responsiveness to issues on their web site, I think it reflects poorly on HiSoftware as a company.

The manner in which properties and entity IDs are encoded into long query string values makes the urls appear to be injection attacks. On a particular client’s BDC application, the picker dialog used a url similar to the following:

http://domainname.org/_layouts/Picker.aspx?MultiSelect=False&CustomProperty=uU2hhcmVQb2ludC5Qb3J0YWwsIFZlcnNpb249MTIuMC4wLAF%2F%2FAQAAAAAAAA9QcmltYXJ5Q29sdW1uSWQQU3lzdGVtSW5zdGFuY2VAAA
AAAMAgAAAF9NaWNyb3NvZnQjAsIEN1bHR1cmU9bmV1dHJhbCwgUHVibG
ljS2V5VG9rZW49NzFlOWJjZTExMWU5NDI5YwUBAAAAPk1pYAEAAAD%2F%2F%23Jvc29mdC5TaGFyZVBvaW50LlBvcnRhbC5XZWJDb250cm9scy5JdGVtUGlja2
VyRXh0ZW5kZWREYXRhB
JZAhFbnRpdHlJZBNTZWNvbmRhcnlDb2×1bW
5zSWRzAAAABw8PDw8CAAAANw4AAAcOAAAIDgAACQMAAAAPAwAAAAAAA
AAPCwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
3D&EntitySeparator=%00&DialogTitle=Choose%20User&DialogImage=%2F_layouts%2Fimages%2Fbizpicker.gif&PickerDialogType=Microsoft.SharePoint.Portal.WebControls.ItemPickerDialog%2C%20Microsoft.SharePoint.Portal%2C%20Version%3D12.0.0.0%2C%20Culture%3Dneutral%2C%20PublicKeyToken%3D71e9bce111e9429c&DefaultSearch=

Using the HTTP GET for this kind of thing is a bad idea, and I hope that Microsoft fixes this in the future.

psconfig -cmd -configdb -create -server DBSERVERNAME -database wss_admin_config -user WSSSERVER\AppPoolAccountName -password p@ssword -dbuser SQLDBUSERNAME -dbpassword p@ssword -admincontentdatabase wss_admin_content

Based on the post here:

http://blogs.msdn.com/fooshen/archive/2007/02/01/installing-moss-without-ad.aspx

With the announcement of the name for the next version of SharePoint on the OFFICIAL SharePoint team blog, I am waiting for the inevitable flood of pingbacks, trackbacks, and reposts about this in my RSS reader. This will be similar to the flood of reposts about “SharePoint Designer is now Free!” I got a week ago. Same goes for the endless stream of tweets and retweets.

Is it really necessary to repost items from the official SharePoint team blog? If you are interested in SharePoint, you should be following this blog already, no?

I think much of this is a direct result of the MVP system and its requirements. When considering candidates for MVP, the quantity of blog posts, page hits, and comments are a big factor. I’ve seen some bloggers with high-quality posts get passed on as MVPs due to low numbers in their web stats. Are some bloggers trying to up their post counts? Is anybody monitoring quality as well as quantity?

I just can’t help but feel that this race to MVP status is encouraging this. Same goes for the MSDN SharePoint forums, where people seem to be falling all over themselves to answer questions as quickly as possible, without providing quality answers or even understanding the questions.

failure trying to synch site [guid] for ContentDB [guid] WebApp [guid].  Exception message was A WSS internal name for profile property ‘ProfilePropertyWithReallyLongName’ could not be found..

Apparently SharePoint has a limit of 32 characters for Internal Field Names. This will also apply to Replicable User Profile Properties since they will get synced down to the WSS Content DB in the UserInfo list.

Scenario:

1. You create a custom Visual Studio workflow and use the CreateTask activity.
2. You set your SPWorkflowTaskProperties.Description property to some HTML text.
3. In your Description HTML text, you have an html hyperlink <a> tag whose href=”” attribute contains an absolute hyperlink to a resource in the same SharePoint farm (i.e. a list item).
4. Example: “Please review <a href=”http://yourserver/site/lists/yourlist/dispform.aspx?ID=1”>contract #12345</a>”.

Goal:

Users will receive the task email, and be able to click on the absolute URL in the email body to navigate to the SharePoint resource.

Problem:

It appears that SharePoint parses this HTML and readjusts the hyperlink and makes it relative.

Example: “Please review <a href=”/lists/yourlist/dispform.aspx?ID=1”>contract #12345</a>”

This effectively breaks the hyperlink in the email client.

The only workaround was to get rid of the <a> tag and write out the hyperlink in full. For example:

“Please review contract #12345 (http://yourserver/site/lists/yourlist/dispform.aspx?ID=1)”.

In this manner, SharePoint did not adjust the hyperlink at all.

Rule of thumb, always specify a default value for each input parameter.

When you have a SharePoint workflow that assigns tasks (either Designer or Visual Studio workflow), when you change the Assigned To column on the task list to allow Multiple Selections, your workflow will hang and become unresponsive when a user edits the task. You’ll receive a message about the task being locked (“This task is currently locked by a running workflow and cannot be edited”). OnTaskChanged events will no longer fire and your workflow will be stuck and unrecoverable.

There is no hotfix or workaround for this, so you simply cannot have the assigned to column support multiple users or groups. Just use a single group instead.

Following are some other resources discussing this:

• http://www.eggheadcafe.com/conversation.aspx?messageid=32931131&threadid=32931131
• http://connect.microsoft.com/wf/feedback/ViewFeedback.aspx?FeedbackID=273487
• http://social.technet.microsoft.com/Forums/en-US/sharepointworkflow/thread/8ec834b6-5408-4079-bdfb-b88d341b36bf/

I recently did a proof of concept for a customer that used a different product, Outside In PDF Export from Oracle. This is an interpretive converter that can take a slew of file formats (including MS Office) and automatically convert them into a PDF file. If you aren’t familiar with PDF conversion, there are two basic kinds:

• Print based conversion – This is the Acrobat Distiller approach. Uses a printer driver that accepts the PostScript output from an application (such as Microsoft Word), and converts it to PDF. This approach results in the most accurate conversions, but is hardest to automate because it involves opening the native application and automating its “Print” functionality.
• Interpretive conversion – This is an approach that reads the contents of a native file format and translates the contents into PDF format. This results in potentially less accurate conversions, but is much easier to automate.

Outside In, and in particular the PDF Export SDK, is an EXE and set of DLLs that contains logic to covert over 400 different file types to PDF. In combination with Transformation Server (a web services wrapper to PDF Export), you can create SharePoint Document Converters that will convert your documents to PDF format.

How I Did It

For the proof of concept, I followed these steps to get it working

• Download PDF Export, Transformation Server, and SrvAny.exe.
• Install and Configure the Transformation Server and Web Service
• Develop and Install the Document Converter

Download of PDF Export 8.3.0 and Transformation Server 8.2.0

You can download both products here:

http://www.oracle.com/technology/products/content-management/oit/oit_dl_otn.html

You’ll have to register with an Oracle account to get it, but it is a freely available trial version, and does not appear to have any trial expiration limitations.

You will also need SrvAny.exe to run Transformation Server as a Windows Service. I found this site that had a download:

http://www.tacktech.com/display.cfm?ttid=197

Install and Configure the Transformation Server and Web Service

Extract the contents of the Transformation Server zip you downloaded to a folder on your server that will do the document conversions (e.g. “C:\PDFConverter”). There will be a bunch of dlls, some wsdl files (we’ll use those later), some EXE’s (which are run as a service), and some XML config files.

Transformation Server doesn’t really know anything about PDF generation, it is just a web service wrapper, so we’ll need to place the PDF Export library into our folder so it can use it. Extract the contents of PDF Export 8.3.0 to a separate folder on your machine. Grab every DLL in the root folder, as well as exporter.exe, px.cfg, and cmmap000.bin and copy those files into “C:\PDFConverter”.

Open the file called server_startup.xml in “C:\PDFConverter”. This configures the service to listen on a specific port and hostname/ip address. I went ahead and changed the port, but you can leave it as is if you wish, just make note of the port for later:

<!--Connections are the TCP/IP socket connections that the server accepts from clients.-->

<connectionsInfo xsi:type="tss:ConnectionsInfo">

    <!--The serverName is the host name, or dotted IP address that the server will use when establishing its presence on the network.-->

    <serverName xsi:type="xsd:string">localhost</serverName>

    <!--The port is the TCP/IP port that the server will establish a listener on for accepting connections.-->

    <port xsi:type="xsd:unsignedInt">9000</port>

    <!--The server will disconnect idle connections that have remained idle for too long. The activityTimeout sets the period of time a connection must be idle before it will be disconnected by the server.-->

    <activityTimeoutSecs xsi:type="xsd:unsignedInt">1800</activityTimeoutSecs>

</connectionsInfo>

Go ahead and double-click tsmanager.exe to make sure it is working. It should open a console window and show you what host/port it is listening on.

Press Ctrl + C to quit.

Now we need to run this program as a service, so that it is always available, even when nobody is logged on to the server. Place instsrv.exe and srvany.exe in your C:\PDFConverter folder. Run the following command prompt:

C:\PDFConverter>instsrv.exe "Transformation Server" c:\PDFConverter\srvany.exe 

The service was successfuly added! Make sure that you go into the Control Panel
and use the Services applet to change the Account Name and Password that this
newly installed service will use for its Security Context.

Open regedit, and browse to HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Transformation Server.

Create a new key called Parameters, and add a new string value inside this key called Application, with a value of C:\PDFConverter\tsmanager.exe.

Go to the services console and start the Transformation Server service. Optionally, you can also go to the Properties for this service account, and change the Identity that this service runs under.

Develop the Document Converter

Create a new .NET C# console application project and solution from within Visual Studio 2008, called PDFConverter.

Right-click the project in Solution Explorer and choose Add Service Reference…

Since the wsdl files for Transformation Server are not compliant with WCF services, choose the Advanced… button on the Add Service Reference dialog, and then choose the Add Web Reference… button to add a .NET 2.0 style web service reference. In the Add Web Reference dialog, enter the path to the wsdl file: C:\PDFConverter\transform_net_2005.wsdl. Hit Go.

Once your web reference has resolved, enter TransformationServer in the Web reference name box and click the Add Reference button.

Open your Properties/Settings.settings file. There will be one setting in the file for the web service URL. Change this to the right hostname/port in your server_settings.xml for Transformation Server. Make sure to include a trailing “/transform” on the end, e.g.:

http://localhost:9000/transform

A document converter is just a console EXE that is called by SharePoint with command line arguments, so we’ll setup our console app to handle the arguments. In Program.cs, before static void Main, add the following code (taken from the WSS SDK here):

#region Argument Handling Data

private enum ArgumentCode

{

    Help,

    InputFile,

    OutputFile,

    LogFile,

    ConfigFile

}

private struct ArgumentPair

{

    public ArgumentPair(ArgumentCode c, string s)

    {

        this.argType = c;

        this.argFlagString = s;

    }

    public ArgumentCode argType;

    public string argFlagString;

}

private static ArgumentPair[] PossibleArguments = new ArgumentPair[] {

    new ArgumentPair(ArgumentCode.Help, "-?"),

    new ArgumentPair(ArgumentCode.Help, "-help"),

    new ArgumentPair(ArgumentCode.InputFile, "-in"),

    new ArgumentPair(ArgumentCode.OutputFile, "-out"),

    new ArgumentPair(ArgumentCode.LogFile, "-log"),

    new ArgumentPair(ArgumentCode.ConfigFile, "-config"),

};

private static Dictionary<ArgumentCode, string> actualArguments = new Dictionary<ArgumentCode, string>();

#endregion

/// <summary>

/// Prints out the usage help to the console.

/// </summary>

static void PrintUsage()

{

    Console.WriteLine("Usage: {0} -in <inputfilename> -out <outputfilename> -config <configfilename> [-log <logfilename>]",

                      Assembly.GetExecutingAssembly().ManifestModule.Name);

}

Add the following code inside static void Main:

#region Argument Handling Code

// Read arguments.

for (int i = 0; i < args.Length; i++)

{

    bool argumentValid = false;

    foreach (ArgumentPair ap in PossibleArguments)

    {

        if (String.Compare(ap.argFlagString, args[i], StringComparison.OrdinalIgnoreCase) == 0)

        {

            switch (ap.argType)

            {

                case ArgumentCode.Help:

                    PrintUsage();

                    return;

                case ArgumentCode.InputFile:

                case ArgumentCode.OutputFile:

                case ArgumentCode.ConfigFile:

                case ArgumentCode.LogFile:

                    if (i + 1 < args.Length)

                    {

                        actualArguments[ap.argType] = args[i + 1];

                        i++;

                        argumentValid = true;

                    }

                    break;

            }

            break;

        }

    }

    if (!argumentValid)

    {

        Console.WriteLine("unknown argument {0}", args[i]);

        PrintUsage();

        return;

    }

}

// Validate arguments.

if (!actualArguments.ContainsKey(ArgumentCode.InputFile) ||

    String.IsNullOrEmpty(actualArguments[ArgumentCode.InputFile]) ||

    !actualArguments.ContainsKey(ArgumentCode.OutputFile) ||

    String.IsNullOrEmpty(actualArguments[ArgumentCode.OutputFile]) ||

    !actualArguments.ContainsKey(ArgumentCode.ConfigFile) ||

    String.IsNullOrEmpty(actualArguments[ArgumentCode.ConfigFile]))

{

    Console.WriteLine("required argument missing");

    PrintUsage();

    return;

}

#endregion

Now that the command line arguments can be parsed, it is time to use the web service and do the document conversion. The Transformation Server download contained some code samples for C#, and I was able to basically use as-is, only modifying the input and output file paths. After the argument handling code in static void Main, add the following code:

TransformationServer.transform t = new TransformationServer.transform();

TransformationServer.IOSpec source = new TransformationServer.IOSpec();

source.spec = new TransformationServer.stringData();

source.spec.base64 = false;

source.spec.charset = TransformationServer.CharacterSetEnum.windows1250;

source.spec.str = actualArguments[ArgumentCode.InputFile];

source.specType = "path";

TransformationServer.IOSpec sink = new TransformationServer.IOSpec();

sink.spec = new TransformationServer.stringData();

sink.spec.base64 = false;

sink.spec.charset = TransformationServer.CharacterSetEnum.windows1250;

sink.spec.str = actualArguments[ArgumentCode.OutputFile];

sink.specType = "path";

string outputFormat = "pdf";

string optionSet = "";

TransformationServer.Option[] options = new TransformationServer.Option[0];

TransformationServer.stringData resultMsg;

TransformationServer.IOSpec[] resultDocs;

UInt32 result = t.Transform(source, sink, outputFormat, optionSet, options, out resultMsg, out resultDocs);

Console.WriteLine("The result is {0} {1}", result, resultMsg.str);

foreach (TransformationServer.IOSpec ios in resultDocs)

{

    ASCIIEncoding encoding = new ASCIIEncoding();

    string constructedString = encoding.GetString(Convert.FromBase64String(ios.spec.str));

    Console.WriteLine(" {0}", constructedString);

}

Most of this code is cut-and-paste from the sample, and we are just swapping the input file path (source.spec.str) and output file path (sink.spec.str) with the arguments from the command line.

Installing the Converter

To install the converter, you need to create a feature file, install the feature, and place the converter EXE in the proper directory.

Create a feature.xml file and add the following:

<Feature xmlns="http://schemas.microsoft.com/sharepoint/"

    Id="{9E2A5231-0D81-4de8-8504-36A61026680E}"

    Title="PDF Converter"

    Description="PDF Converter."

    Scope="WebApplication">

  <ElementManifests>

    <ElementManifest Location="Elements.xml"/>

    <ElementFile Location="PDFConverter.exe"/>

  </ElementManifests>

</Feature>

Create an Elements.xml file, and add the following code. You can create as many document converter nodes as you need for each file type you want to convert (just make sure each has a unique guid).

<Elements xmlns="http://schemas.microsoft.com/sharepoint/">

  <DocumentConverter Id="{513130EB-A1BC-46d3-919C-1E00B6BCA742}"

      Name="DOCX to PDF Converter"

      App="PDFConverter.exe"

      From="docx"

      To="pdf"

    />

  <DocumentConverter Id="{E7374437-157E-4fb4-A4E9-A19026BAE17A}"

    Name="VSD to PDF Converter"

    App="PDFConverter.exe"

    From="vsd"

    To="pdf"

    />

</Elements>

Place both these files in a folder called PDFConverter in your …/12/TEMPLATE/Features folder, and use stsadm to activate the feature on a particular web application.

C:\Program Files\Common Files\Microsoft Shared\web server extensions\12\BIN>stsadm
-o installfeature -name PDFConverter 

Operation completed successfully.  

C:\Program Files\Common Files\Microsoft Shared\web server extensions\12\BIN>stsadm
-o activatefeature -name PDFConverter -url http://mossdev:8080 

Operation completed successfully.

After activating the feature, go to Central Administration, Applications tab, and click the Document Conversions link. Ensure that your web application has document conversions turned on. You should see your document converters in the list at the bottom of the screen:

Since you are using a Web Service, a proxy class needs to be generated dynamically, and so you’ll need to give your SharePoint Document Conversion User Account rights to create this in C:\Windows\Temp (or whatever your system temp directory is). Grant List Folder Contents and Read permissions to the Document Conversion account (usually a local machine account that starts with “HVU_”) on your Temp folder.

The Document Conversion service stores temporary documents in the following folder: C:\Program Files\Microsoft Office Servers\12.0\BIN\HtmlTrLauncher. By default, this folder only grants the Document Conversion User account access. Since the Transformation Server windows service is running under its own account, you need to give this account access to the folder. Grant the account that your Transformation Server windows service is running under Read and Write access to this folder.

The last step involves copying over your compiled console EXE and exe.config file into the following SharePoint folder (the actual path may vary depending on your setup, but you should be able to find the TransformApps folder):

C:\Program Files\Microsoft Office Servers\12.0\TransformApps

Results

Navigate to your SharePoint site. Upload a document into your document library (make sure it is a file extension that you’ve configured in your Elements.xml file). Open the drop down menu and choose Convert Document. Your document converter should appear in the list. Run the conversion. After around a minute if you refresh your document library and all went well, you should see your PDF file in the library.

Here is a picture of a generated Visio document in PDF format, not too bad:

I used the Properties node of the feature.xml file to store the settings:

<Feature xmlns="http://schemas.microsoft.com/sharepoint/"...>

  <Properties xmlns="http://schemas.microsoft.com/sharepoint/">

    <!-- The name of the timer job (will appear in Central Admin). -->

    <Property Key="JobTitle" Value="Your Timer Job Name Here"/>

    <!-- Connection String that the TimerJob will use -->

    <Property Key="ConnString" Value="ConnectionString..."/>

    <!-- The schedule to run the job in (24 hour format) -->

    <Property Key="Schedule" Value="daily at 02:00:00"/>

  </Properties>

</Feature>

Then, during the FeatureActivated event, I passed those values into the Properties bag on the Timer Job class:

public override void FeatureActivated(SPFeatureReceiverProperties properties)

{

    // Get all the properties from the feature.xml file

    string jobTitle = properties.Feature.Properties["JobTitle"].Value;

    string connString = properties.Feature.Properties["ConnString"].Value;

    string dailySchedule = properties.Feature.Properties["Schedule"].Value;

    // Create the job.

    CustomTimerJob customTimerJob = new CustomTimerJob((SPWebApplication)properties.Feature.Parent, jobTitle);

    // Set the properties for the job to run properly

    customTimerJob.Properties.Add("ConnString", connString);

    customTimerJob.Properties.Add("Schedule", dailySchedule);

    // Set the schedule

    SPSchedule mainSchedule = SPSchedule.FromString(dailySchedule);

    customTimerJob.Schedule = mainSchedule;

    // Activate the schedule

    customTimerJob.Update();

}

Then, in the Timer Job’s Execute method, grabbed those settings and used them:

public override void Execute(Guid targetInstanceId)

{

    // Set up configuration values

    string connString = this.Properties["ConnString"] as string;

    ...

}

I didn’t have a need to make run-time changes to the configuration settings, so this worked out really well. To change the defaults and apply new settings, the process was as simple as:

• Deactivate the feature (uninstalls the Timer Job)
• Change the feature.xml file
• Re-activate the feature

When running a job on a recordset of this size, there are several things to strive for:

• Limit the time that the process needs to run (jobs can take days and overlap themselves)
• Reduce memory usage (the OWSTIMER.exe can already consume quite a bit with the regular timer jobs)

Two ways you can achieve this:

• Avoid UserExists() method
• Use a DataReader if possible
    

Avoid UserExists() method

Most code samples on the web that deal with programmatic creation of User Profiles will show code such as this:

if (profileManager.UserExists(accountName)

{

    userProfile = profileManager.GetUserProfile(accountName)...

}

else

{

    userProfile = profileManager.CreateUserProfile(accountName)...

}

On small recordsets, this is fine, but for large recordsets the UserExists method represents a bottleneck that can increase the duration that your process runs. In addition, in the code above, you will unknowingly call this method a second useless time, because the CreateUserProfile() method internally calls UserExists() as well.

There are two ways to avoid this method:

• Cache profile IDs in a Dictionary/Hashtable type object
• Use reflection to create user profiles

Cache Profile IDs (and MemberGroup IDs too)

The UserProfileManager object is an IEnumerable that you can iterate over and access all the Profiles in SharePoint. Caching the IDs of these profiles up front enables you to index into a Dictionary object to see if your profile exists, rather than hitting SQL Server with UserExists(). The following code helped to reduce processing time significantly (you take a hit up front, but it’s far less than the delay imposed by UserExists over large recordsets):

Dictionary<string, Guid> cachedProfiles = new Dictionary<string, Guid>();

foreach(UserProfile profile in profileManager)

{

    cachedProfiles.Add(profile.AccountName, profile.ID);

}

...

if(cachedProfiles.ContainsKey(accountName)

{

    ...

}

In addition, caching the Guid of the UserProfile lets you later use the overloaded method of GetUserProfile() that takes a Guid as a parameter, which seems to perform slightly better than the alternative that takes a string for AccountName.

This approach also works very well when importing large numbers of MemberGroups:

foreach (MemberGroup memberGroup in memberGroupManager)

{

    cachedMemberGroups.Add(memberGroup.DisplayName, memberGroup.Id);

}

NOTE: If you are wondering why not simply cache the entire UserProfile in the Dictionary (Dictionary<string, UserProfile>), the memory usage for this will be much higher, which will undo any gains by avoiding UserExists().

Use Reflection to Create User Profiles

The UserProfileManager’s CreateUserProfile() method internally calls the UserExists method, and then calls an internal constructor on the UserProfile object to actually create the profile. By using reflection, you can call this internal constructor yourself and avoid UserExists():

// Get some reflected information about the UserProfile object for later use

ConstructorInfo ci = typeof(UserProfile).GetConstructor(

BindingFlags.NonPublic | BindingFlags.Instance,

null,

new Type[] { typeof(UserProfileManager), typeof(string), typeof(string) },

null);

Once you’ve got the reflected information, you can use the following code to create your UserProfile:

if (cachedProfiles.ContainsKey(accountName))

{

    // Get existing profile...

}

else

{

    // Create new profile

    UserProfile newProfile = (UserProfile)ci.Invoke(new object[] { profileManager, accountName, displayName });

}

NOTE: I’ve tried creating a user profile in this manner that already existed to see what would happen. The existing profile was updated, and I did not get any duplicate records in the SharePoint db. It appears the SQL under the hood already takes care of avoiding duplicates. General cautions about reflection still apply here though (API may change, etc.).

Use a DataReader if Possible

Instead of pulling a huge recordset into a DataTable, DataSet, or into a collection of custom objects, try to process your records one at a time using a data reader if your data source permits. This will keep memory usage down, as the garbage collector will dispose frequently any variables you create within a while(reader.Read()) loop. A DataTable with 1 million records in it will take up tons of memory on top of the large memory consumption that OWSTIMER.exe does already.

using (OracleConnection conn = new OracleConnection(_connectionString))

{

    using (OracleCommand cmd = new OracleCommand(_sqlGetAllUsers, conn))

    {

        conn.Open();

        OracleDataReader rdr = cmd.ExecuteReader();

        if(!rdr.HasRows())

        {

            return;

        }

        while (rdr.Read())

        {

            UserProfile profile = null;

            string accountName = rdr["ACCOUNT_NAME"] as string;

            string firstName = rdr["FIRST_NAME"] as string;

            string lastName = rdr["LAST_NAME"] as string;

            if (cachedProfiles.ContainsKey(accountName))

            {

                profile = profileManager.GetUserProfile(cachedProfiles[accountName]);

            }

            else

            {

                profile = (UserProfile)ci.Invoke(new object[] { profileManager, accountName, displayName });

                cachedProfiles.Add(accountName, profile.ID);

            }

            if (!string.IsNullOrEmpty(firstName))

            {

                profile["FirstName"].Value = firstName;

            }

            if (!string.IsNullOrEmpty(lastName))

            {

                profile["LastName"].Value = lastName;

            }

            // ... 

            profile.Commit();

        }

        rdr.Close();

        rdr.Dispose();

    }

}

Of course other best practices also apply, such as:

• Getting pages of records, rather than all at once
• Implementing incremental change queries rather than all records all the time
• Only getting what you need from the data source
• Disposing your objects and data connections properly

Running through the Request Access pages, it appeared that SharePoint did not think the user had rights to the task list, even though they did after thoroughly checking permissions.

I figured that it was having trouble with permissions to the ASPX pages from the Designer-generated tasks forms, so I solved it by doing the following:

• Open the site in SharePoint designer
• Locate the “Workflows” node in the tree view.
• Right-click “Workflows” and select Properties.
• Click the Security tab.
• Choose the option to manage permissions from the browser.

It turns out that this “Workflows” node is actually a SharePoint folder object, and it turned out that this folder did not inherit permissions from the parent. The web page for managing permissions that came up showed me this, and enabled me to reinherit permissions and fix the problem.

I’m not sure why that folder didn’t inherit permissions though, I’d never seen that before.

This link from MSDN (see the Notes section) helped me to identify that the NTFS permissions were screwed up on the feature folder and files (since I created them through windows explorer). Re-inheriting permissions from the parent “Features” folder solved the problem.

• Andrew Connel’s articles:
  • http://andrewconnell.com/blog/archive/2007/01/10/5704.aspx
  • http://www.andrewconnell.com/blog/articles/CreatingCustomSharePointTimerJobs.aspx
  • http://andrewconnell.com/blog/archive/2007/07/02/6067.aspx
  • http://www.andrewconnell.com/blog/archive/2008/04/15/More-help-on-creating-custom-timer-jobs-and-a-useful.aspx
• MSDN article – http://msdn2.microsoft.com/en-us/library/cc406686.aspx
• Logging – http://trentacular.com/2008/12/sharepoint-logging-and-microsofts-trace-log-provider/
• Scheduling using more natural language – http://blogs.msdn.com/markarend/archive/2007/01/16/spschedule-fromstring-recurrencevalue-syntax-format-for-recurrence-value.aspx
• Feature Help:
  • xmlns comment at bottom of this page: http://msdn.microsoft.com/en-us/library/ms436075.aspx
  • Debugging feature receivers: http://bphillips76.spaces.live.com/blog/cns!F9B548E4C21D6166!445.entry
  • Note section of this page, talking about proper permissions necessary for your feature files: http://msdn.microsoft.com/en-us/library/ms460318.aspx

1. Go to Tools > Form Options.
2. Click the Open and Save option.
3. Click the Rules button, and add rules and actions to switch views.

With this method, I was able to set a field on form submittal to indicate which view was last active. When the submitted form was re-opened, I was able to use a conditional rule to switch to that last active view.

The easiest way to do this is to create conditional rules in the Submit Options dialog:

1. Configure your form and add a Contact Selector control (see this article for instructions).
2. Go to Tools > Submit Options.
3. Make sure that Allow Users to Submit this Form is checked.
4. Click the option to Perform custom action using rules.
5. Click the Rules… button.
6. In the Rules dialog, click the Add… button.
7. In the Rule dialog, click the Set Condition… button.
8. In the Condition dialog, pull down the first dropdown, choose Select a field or group…, and drill down and choose the DisplayName field from your data connection. Select is blank in the second dropdown.
9. Click the And> button to add a second condition.
10. In the last dropdown on the first condition, change it from And to Or.
11. In the second condition, select the DisplayName field again, and choose is not present for the condition. Your two conditions should look like this:

12. 

13. Click OK. In the Rule dialog, do not add any Actions. Check the box to Stop processing rules when this rule finishes.
14. Make sure that this rule appears first in the list of Rules.

The only downside to this approach is that there is no visual to the user, since InfoPath Forms Services does not support showing a dialog message. The form will just not do anything. To get an even better user experience, You can hide the Submit option from the Toolbar, and use your own Submit buttons with Conditional Formatting:

1. Drag a button on the page.
2. Right-click and choose Conditional Formatting….
3. Click Add… to add conditions.
4. In the Condition dialog, add the two conditions in steps 8-11 above, and choose Disable this Control.
   

   

Now, your submit button will be disabled until the user picks a person.

We verified that users were explicitly added into the “Members” group of SharePoint sites, we performed full crawls and ran all the timer jobs. Still no dice.

Eventually, a support ticket with MS revealed that having the Content Database set to Offline prevented that functionality from working.