Muhimbi's SharePoint Blog

Using SharePoint Forms Services to convert InfoPath forms to PDF format

2010-08-31T19:22:00.001+01:00

Our popular PDF Converter for SharePoint has been able to convert InfoPath document to PDF format for quite some time and, even though we are continuously improving it with new functionality such as Dynamic View Selection and the ability to convert InfoPath attachments, you just can’t please everyone all the time.

For example, to achieve the best possible conversion fidelity our product requires InfoPath to be installed on the conversion server. This works great, but in some (mainly externally hosted) environments, this is not always possible. Fortunately the 4.0 version of the PDF Converter for SharePoint now comes with support for converting InfoPath forms to PDF format using InfoPath Forms Services, which is included with the Enterprise version of SharePoint 2007 & 2010.

This can be very useful for some environments, but there are some limitations with this technique:

InfoPath Forms services is required so it doesn’t run on the base WSS3 or SharePoint Foundation versions.
It only works with Forms that are Browser enabled.
Dynamic View Selection and conversion of Attachments features are not available, although it is possible to specify the name of the View to convert.

Our traditional approach that uses InfoPath on the server does not have these limitations.

The upcoming release will be a big one so keep an eye on the other posts in this series. You may also want to consider subscribing to our RSS feed or following us on Twitter. If you are interested in participating in the beta program then please drop us a line.

From Browser based form (left) to PDF Document (right). Click image to open the full PDF file.

Let’s show how to use Form Services in combination with the PDF Converter for SharePoint to convert InfoPath Documents. Some familiarity with both InfoPath and SharePoint is assumed. If you have any questions after reading this then leave a message in the comments section at the end of this post or contact us.

Request the latest beta version of the PDF Converter for SharePoint and install it.
Make sure you have the appropriate privileges to create workflows on a site collection.
Start InfoPath, select Customize a Sample and double click on Sample – Expense Report.
From the File menu select Publish and go through the usual steps to publish the form to a new SharePoint Library named Expenses.
In the new Expenses document library, fill out a form and save it as Form1.xml.
Create a new workflow using SharePoint Designer.
On the Workflow definition screen associate the workflow with the new Expenses list, tick the boxes next to both ‘Automatically start….’ options and proceed to the next screen.
Add the Convert HTML to PDF action, click this url / html and enter the path to your site collection followed by Muhimbi’s InfoPathPrint.aspx page, e.g. http:/moss/sites/Finance/_layouts/Muhimbi.PDFConverter/InfoPathPrint.aspx
Don’t close the String Builder dialog yet. Add the xmlLocation querystring parameter, click the Add Lookup button and select the Server Relative URL field for the Current Item. The final result should look like the following screenshot.
Close the String Builder and click the this file option. Assuming we want to write the converted PDF file to the Shared Documents library enter Shared Documents/[%Expenses:Name%].pdf. (Insert the underlined text using the Lookup button. Just typing it in will not work).
Optionally change the orientation of the page to Landscape. There should be no need to specify the username and password as by default the credentials the Document Conversion Service runs under will be used for authentication with the aspx page.
Close the workflow to save and activate it.

Add a new form to, or update an existing one in, the Expenses library. After a few seconds the Workflow Status should change to Completed. Once complete the converted PDF document can be opened from the Shared Documents library.

If your InfoPath form contains multiple views then you can select which view to convert by concatenating &ViewName=your_view_name to the URL of InfoPathPrint.aspx.

In summary, if it is not possible to install InfoPath on the server in your environment, or if your forms look better in Forms Services compared to the full InfoPath client (it does happen), then use the technique described in this post to convert InfoPath documents to PDF format using InfoPath Forms Services.

As always, upgrades are completely free. Don’t hesitate to leave a comment below if you have any questions or contact us to participate in the beta program

Converting SharePoint Lists to PDF format using a SharePoint Designer Workflow

2010-08-31T16:52:00.001+01:00

As one of the leading vendor in the SharePoint PDF Conversion market, we are frequently asked about how our products can be used to convert a SharePoint List into a PDF file. Up until now we have never had a good answer to this question as we mainly deal with the conversion of Office Documents and InfoPath forms.

However, as the upcoming version 4.0 of the PDF Converter for SharePoint and PDF Converter Services support the conversion of HTML based content we can now export any SharePoint page, including ones that contain all entries in a list, to a PDF Document. This article shows how to put this together.

OK, let’s get going. In this example we use a simple Tasks list, so open your SharePoint site and create a Tasks lists if one doesn’t already exists.

Next up we need to create a page that displays all items in the list with as little of the SharePoint User Interface around it as possible. We could just use the list’s default view, but that would convert the Quick Launch menu to PDF as well, which doesn’t look very clean. To create a new page without the Quick Launch menu follow these steps:

Navigate to the View All Site Content screen and click the Create button.
In the Web Pages column select Web Part Page.
Name the page PDFTasks.aspx, choose the Full Page, Vertical template and click the Create button.
On the newly created page click Add a Web Part and add the Tasks list.
Click the newly inserted Web Part’s Edit button and select the Modify Shared Web Part option.
Click Edit the current View and select the columns you want to be included in the PDF file. For example % Complete, Due Data, Start Date and Status. Do not close the screen yet.
Under the Item Limit section set the limit to an appropriately large number. We don’t want to page through the data in batches as we want to include all items in the PDF file.
Click OK to save the changes.
Save the page’s URL as we need it later. E.g. http://moss/sites/Management/FormServerTemplates/PDFTasks.aspx.

This new page will be used as the underlying layout of the PDF document. Feel free to modify it further in SharePoint designer / JQuery and remove more parts of the SharePoint user interface. You could also consider creating a minimalistic master page and applying that to the new PDFTasks page.

With the page in place the next thing we need to do is setup the automatic PDF Conversion using a SharePoint Designer workflow. In this example we generate a PDF file whenever the Tasks list is modified. The generated PDF file is stored in the Shared Documents library. Create the workflow as follows:

Request the beta version of the PDF Converter for SharePoint and install it.
Make sure you have the appropriate privileges to create workflows on a site collection.
Create a new workflow using SharePoint Designer.
On the Workflow definition screen associate the workflow with the Tasks list, tick the boxes next to both ‘Automatically start….’ options and proceed to the next screen.
Add the Convert HTML to PDF action and click on this url and enter the URL to the page that was created in a previous step, e.g. http://moss/sites/Management/FormServerTemplates/PDFTasks.aspx.
Click this file and enter the path and file name where the PDF file will be generated, e.g. Shared Documents/Tasks.pdf.
Optionally change the generated page’s orientation from Portrait to Landscape.
The user name and password are optional. By default the credentials the Muhimbi Conversion Service runs under will be used to open the web page. For now leave it empty.
Click the Finish button to activate the workflow.

As a test enter one or more tasks. Every time a task is added or updated a PDF file is written to Shared Documents/Tasks.pdf. Open the PDF file to see the results.

In summary, the HTML conversion capability of the new version opens up a whole array of new possibilities. As always, upgrades are completely free. Don’t hesitate to leave a comment below if you have any questions or contact us to participate in the beta program

Controlling which views to export to PDF format in InfoPath

2010-08-20T15:08:00.001+01:00

Next up in our series about new features in the upcoming release of the PDF Converter for SharePoint and PDF Converter Services, we’ll showcase some of the new Export to PDF View Selection capabilities of our InfoPath converter.

Being able to select which views to export is very useful as quite often different views are used for exporting a form to PDF. Sometimes using the Print View is good enough, but other times you need to export a different view or multiple views to PDF format. There are even occasions where different views are exported depending on the state of the data entered in the form.

As always, the best way to illustrate this is by example.

Use a special view for exporting to PDF

In this scenario we have an Employee Review form with the following 3 views:

Data entry view: A view used for populating data using the InfoPath client or Forms Services. This is the default view.
Print View: A special view that is optimised for printing to a network laser printer. This is specified as View 1’s Print View.
PDF Export view: A separate view that is used to export the InfoPath form to PDF format as it contains some information that should only show up in exported PDF files.

As View 1 is the default view and View 2 is the Print View for View 1, under normal circumstance the 2nd view is used for exporting to PDF. However, we want to use View 3 for this purpose. We can achieve this by starting the name of View 3 with “_MuhimbiView”. The Muhimbi PDF Converter will automatically detect all views that start with this name, export them all and merge them together into a single PDF file. Naturally these views can be hidden from the end user by marking them as such.

This is a great solution if you know beforehand that you will always be exporting the same view(s) to PDF format.

Determine at runtime which views to export

The previous solution, using view names that start with “_MuhimbiView”, works great. However, sometimes you need to export a different view depending on the state of the data.

For example, our Expense Claim form consists of the following Views:

Data Entry View 1: Used by the employee to report expenses.
Data Entry View 2: Used by the manager to add comments and additional information.
PDF Export View 1: The view that is used to export the form to PDF format before the manager has reviewed the form.
PDF Export View 2: The view that is used to export the form to PDF format after the manager has reviewed the form.

OK, so how are we going to deal with this? Well, here comes the Muhimbi PDF Converter to the rescue! By adding a (hidden) text box named “_MuhimbiViews” (case sensitive) to any of the views and populating it with the name of one or more comma separated view names, the Muhimbi PDF Converter will automatically pick up these names and export them to PDF format. If multiple views are specified then they are automatically concatenated together.

In addition to adding the “_MuhimbiViews” text field to the form, all the developer of the form needs to do is to add a little bit of logic to the Submit event of the 2 data entry views that specify the correct view name to export in the “_MuhimbiViews” field.

View prioritisation rules

To determine which view or views to export, the Muhimbi PDF Converter uses the following prioritisation rules:

If a field named “_MuhimbiViews” is found anywhere in the InfoPath form then the content of this field is used to determine which views to export.
If the previous field does not exist, is empty or the specified view name does not exist then the converter looks at all view names that start with “_MuhimbiView”.
If none of the previous options apply then the view marked as the Default View is exported.

Regardless of how a view or views are selected for export, if the selected view has a Print View specified than that view is given priority.

InfoPath's 'Print multiple views' option is not used when exporting views to PDF. This is by design as the views defined in this setting may already be used for other (non PDF) based printing purposes.

When all elements are combined into the final PDF file then all views are copied first followed by any converted attachments.

In summary, the new version of the PDF Converter adds flexible View selection features to make the life of InfoPath developers easier. As always, upgrades are completely free. Don’t hesitate to leave a comment below if you have any questions or contact us to participate in the beta program

Convert SharePoint HTML pages to PDF format

2010-08-19T15:12:00.001+01:00

As part of our ongoing series about new features in the upcoming release of the PDF Converter for SharePoint and PDF Converter Services, we would like to showcase our exciting new HTML to PDF conversion functionality.

We anticipate that most of our customers will use this functionality to convert SharePoint pages, including lists, to PDF format. However, rather than displaying a boring old SharePoint site, let’s show how well this works with a real website, in this case one of our landing pages.

UPDATE: A workflow activity is now available as well for converting HTML to PDF.

The following image shows the original HTML page on the left hand side and the converted PDF file on the right. As you can see this works very well.

Example of the original web page (left) and the converted PDF file (right)

A summary of the new HTML features are as follows. Although this new functionality is available in both the PDF Converter Services as well as the PDF Converter for SharePoint, some of the more SharePoint centric features in the list are obviously exclusive to the SharePoint version.

Built on top of Muhimbi’s rock solid service platform. No need to worry about runaway or orphaned processes. Everything is nicely controlled and scales over multiple CPUs and conversion servers.
Integrates with the full feature set of Muhimbi’s PDF Conversion platform including full control over watermarks as well as PDF Security settings.
High fidelity conversion (See image above) including multi page documents and JavaScript output. The generated PDF file contains real (searchable) text and is not just a low resolution screenshot of the converted web page.
Supports conversion by URL as well as manually specified HTML fragments. Ideal for creating PDF based reports using generated HTML tables.
Convert HTML documents stored inside SharePoint document libraries.
Convert SharePoint pages to PDF format from the user’s Personal Actions menu.
Convert web pages to PDF format from SharePoint workflows. Works great in combination with publishing sites.

HTML to PDF Conversion is accessible via the web services based interface as well. Listed below is a simple C# example of how to carry out a conversion from your own code. The code is not complete as it calls into some shared functions from our main C# example to keep things short.

Our existing Java based examples can easily be extended to carry out the same type of conversions. Contact us if you need a hand, we love to help and are very responsive.

/// <summary>

/// Simple sample to convert either a URL or HTML code fragment to PDF format

/// </summary>

/// <param name="htmlOnly">A flag indicating if an HTML Code fragment (true)

/// or URL (false) should be converted.</param>

private void ConvertHTML(bool htmlOnly)

    DocumentConverterServiceClient client = null;

try

        string sourceFileName = null;

        byte[] sourceFile = null;

        client = OpenService("http://localhost:41734/Muhimbi.DocumentConverter.WebService/");

        OpenOptions openOptions = new OpenOptions();

        //** Specify optional authentication settings for the web page

        openOptions.UserName = "";

        openOptions.Password = "";

        if (htmlOnly == true)

            //** Specify the HTML to convert

            sourceFile = System.Text.Encoding.UTF8.GetBytes("Hello <b>world</b>");

        else

            // ** Specify the URL to convert

            openOptions.OriginalFileName = "http://www.muhimbi.com/";

        openOptions.FileExtension = "html";

        //** Generate a temp file name that is later used to write the PDF to

        sourceFileName = Path.GetTempFileName();

        File.Delete(sourceFileName);

        // ** Enable JavaScript on the page to convert.

        openOptions.AllowMacros = MacroSecurityOption.All;

        // ** Set the various conversion settings

        ConversionSettings conversionSettings = new ConversionSettings();

        conversionSettings.Fidelity = ConversionFidelities.Full;

        conversionSettings.PDFProfile = PDFProfile.PDF_1_5;

        conversionSettings.PageOrientation = PageOrientation.Portrait;

        conversionSettings.Quality = ConversionQuality.OptimizeForPrint;

        // ** Carry out the actual conversion

        byte[] convertedFile = client.Convert(sourceFile, openOptions, conversionSettings);

        // ** Write the PDF file to the local file system.

        string destinationFileName = Path.GetDirectoryName(sourceFileName) + @"\" +

                                            Path.GetFileNameWithoutExtension(sourceFileName) +

                                            "." + conversionSettings.Format;

        using (FileStream fs = File.Create(destinationFileName))

            fs.Write(convertedFile, 0, convertedFile.Length);

            fs.Close();

        // ** Display the converted file in a PDF viewer.

        NavigateBrowser(destinationFileName);

    finally

        CloseService(client);

All in all some pretty exciting functionality. Don’t hesitate to leave a comment below if you have any questions or contact us to participate in the beta program.

Converting InfoPath forms including all attachments to a single PDF file

2010-08-19T11:15:00.001+01:00

Over the next few days I will be writing about the new features in our upcoming release of the PDF Converter for SharePoint and PDF Converter Services. As this release will be a big one it won’t all fit in one post, so stay tuned and consider subscribing to our RSS feed or follow us on Twitter.

If you are interested in participating in the beta program then please drop us a line.

In today’s post I will explain the new functionality that allows files attached to InfoPath forms using the File Attachment control to be converted to PDF together with the main InfoPath form. All files will be merged into a single PDF file that contains both the InfoPath form and all attachments.

This all works amazingly well and some of the people in our beta program are already using this feature successfully. In summary the functionality is as follows:

Automatic attachment conversion is enabled by default. Change the InfoPathConverterFullFidelity.ConvertAttachments setting in the Muhimbi service’s config file to False to disable conversion of attachments.
You don’t need to know anything about the form that is being converted, nor do you need any programming knowledge, this functionality is truly universal. All attachments are automatically picked up, including attachments in Repeating Sections and Repeating Tables.
All document types supported by the Muhimbi PDF Conversion engine are recognised. Files that are not supported are automatically skipped. For a full list of supported file formats see the Specification tab on the main product page.
Naturally attached PDF files are merged in as well, which is great for such attachments as scanned receipts or received faxes.
Do not attempt to attach an InfoPath form inside another form. This will result in an error.
This functionality works hand-in-hand with the new Export Multiple Views functionality that I will outline in an upcoming post.
As all this work is carried out inside Muhimbi’s core conversion engine, any additional conversion settings such as watermarks and security settings are automatically applied to all pages of the combined PDF file.

Convert Expense Reports with attached receipts to a single PDF

So, a very useful new feature that provides powerful new functionality to our customers. As always, upgrades are completely free. Don’t hesitate to leave a comment below if you have any questions or contact us to participate in the beta program.

Dealing with hyperlinks when converting InfoPath files to PDF format

2010-08-18T18:58:00.001+01:00

We get a lot of questions from customers about what happens to hyperlinks in InfoPath documents when the documents are converted to PDF format using the Muhimbi PDF Converter for SharePoint.

We ran the possible combinations through some tests with the following results:

InfoPath TextBox elements with the type set to 'text' become hyperlinks when a URL is entered in it (or at least the PDF Reader navigates to that URL when clicked).
InfoPath TextBox elements with the type set to 'URL' become hyperlinks when a URL is entered in it (or at least the PDF Reader navigates to that URL when clicked).
Entering a URL in an InfoPath Rich Text Box and pressing the Enter key automatically generates a blue hyperlink. When a document containing this link is converted to PDF format then the link can be clicked in the converted document as well.
Entering text in an InfoPath Rich Text Box, selecting it and using the Insert Hyperlink command creates a clickable link in the InfoPath Document. However, after converting this document to PDF format this link is not clickable.
InfoPath Hyperlink Fields are correctly converted and remain hyperlinks in the PDF document.

I hope this clarifies the situation.

Workflow Power Pack 1.2.0.6 – Patch release for SharePoint 2010

2010-08-18T11:45:00.001+01:00

We just published a patch release of the Workflow Power Pack for SharePoint. No new functionality, just a fix to deal with what we believe to be a bug in the way SharePoint 2010 deals with custom Workflow Activity Validators.

Due to the manner SharePoint 2010 deals with lookup fields in custom activity validators, any custom code that contains lookup values (e.g. [%Current Item:Transaction Date%]) will not be validated when a workflow is published. We believe this to be a bug in SharePoint 2010 as this works fine in SharePoint 2007.

If this is a big problem for you then consider passing in the lookup field as either parameter 1 or parameter 2 and refer to it using MyWorkflow.Parameter1. For details on how to use the MyWorkflow object in your own code, see the User Guide Series.

Code that does not contain lookup fields is validated properly. Regardless of the scenario, the code does execute correctly.

SharePoint 2007 environments are not affected by this bug.

Download the latest version.

SharePoint Infuser, URL Shortener & Workflow Power Pack Webinar recording

2010-08-11T08:30:00.001+01:00

The 3rd recording in our series of SharePoint webinars is now available for download / streaming. This final recording discusses and demonstrates the free Muhimbi SharePoint Infuser in addition to the URL Shortener for SharePoint and the Workflow Power Pack.

The other 2 recordings, dealing with our popular PDF Converter for SharePoint and the SharePoint Audit Suite, are available for viewing as well. 3 Webinars in one week….. I am knackered.

Download / stream the presentation in WMV format. The slides are also available in PDF format.

Some of the demos featured in the presentation are also available as separate blog posts:

Workflow Power Pack

URL Shortener for SharePoint

Create Shortened (‘TinyURL’) links from your SharePoint Workflow

SharePoint Infuser

Enjoy watching it. As always, if you have any questioned then don’t hesitate to contact us. We are very helpful and answer any questions as quickly as we can.

SharePoint Audit Suite recorded Webinar now available for live streaming

2010-08-10T18:51:00.001+01:00

We carried out a live webinar the other day to talk about and demonstrate our SharePoint Audit Suite. Based on the feedback, and the number of attendees, it was a great success. A similar presentation about our popular PDF Converter for SharePoint is available as well.

Fortunately for those who did not attend, we recorded the whole event, which is now available for real-time streaming. It is worth watching as it contains a lot of information, including some details about our upcoming ‘2.0’ version.

Download / stream the presentation in WMV format. The slides are also available in PDF format.

Enjoy watching it. As always, if you have any questioned then don’t hesitate to contact us. We are very helpful and answer any questions as quickly as we can.

Maintenance release for SharePoint Infuser 1.0.1.2

2010-08-09T17:50:00.001+01:00

Just a quick note to announce the availability of a maintenance release of the free Muhimbi SharePoint Infuser.

Nothing too exciting, just a bug fix that affects solutions where a user may have access to a sub site without having access to the root site.

Download it here, check out examples here.

Shortest Muhimbi Blog post Ever!

PDF Converter for SharePoint recorded Webinar now available for live streaming

2010-08-04T11:20:00.001+01:00

Yesterday we carried out a live webinar to talk about and demonstrate our popular PDF Converter for SharePoint. Based on the feedback, and the number of attendees that stayed on till the very last minute, it was a great success.

Fortunately for those who did not attend, we recorded the whole event, which is now available for real-time streaming. It is worth watching as it contains lots and lots of demos including PDF Conversion using Web Services, use in combination with SharePoint Designer workflows, conversions using InfoPath, Watermarking, use in combination with the Workflow Power Pack etc etc.

Download / stream the presentation in WMV format. The presentation is available on this secondary (streaming only) link as well. The slides are also available in PDF format.

Some of the demos featured in the presentation are also available as separate blog posts:

Enjoy watching it. As always, if you have any questioned then don’t hesitate to contact us. We are very helpful and answer any questions as quickly as we can.

PDF Converter Services 3.5 – Adds watermarking and pluggable converters

2010-06-28T10:23:00.003+01:00

It is that time of the month again where we release new versions of our server based PDF Conversion products. Today’s release of the Muhimbi PDF Converter Services adds native support for the much requested Watermarking functionality as well as the ability to add custom converters using a new plug-in architecture.

A quick introduction for those not familiar with the product: The Muhimbi PDF Converter Services is a server based SDK that allows software developers to convert typical Office files to PDF format using a robust, scalable but friendly Web Services interface from Java and .NET based solutions. It supports a large number of file types including MS-Office and ODF file formats and is used by some of the largest organisations in the world for mission critical document conversions. A separate SharePoint specific version is available as well.

For details about the new functionality as well as a breaking change see the following posts:

New Web Services classes related to watermarking. Click to enlarge

The main changes in version 3.5 are as follows:

865	New – Add support for watermarks, headers & footers using the Web Services interface.
837	New – Add support for custom converters using a plug-in architecture.
878	Improved – Allow server side Exception details to be (optionally) passed to WS Clients .
883	Improved – Include watermarking in the Java based sample code.
874	Improved – Include watermarking in the .NET based sample code.
876	Improved – Update documentation with details about watermarking and custom converters.

For more information check out the following resources:

As always, feel free to contact us using Twitter, our Blog, regular email or subscribe to our newsletter.

Download your free trial here (5MB).

Breaking changes in the PDF Converter 3.5 Web Services interface

2010-06-15T17:23:00.001+01:00

In preparation of the upcoming 3.5 release of the Muhimbi PDF Converter Services we are making sure that all required documentation is readily available on our website (See previous posts on watermarking and custom converters).

Unfortunately, today I am documenting something I had hoped I would never need to document, a breaking change in our Web Services interface that may require our existing customers to refresh their web service proxies. Fortunately the change is isolated to a little used configuration interface, the main Convert method will continue to work fine….. pfew.

Background

Our range of PDF Conversion products all share the same core engine, which runs as a Windows Service and can be accessed via an industry standard Web Services interface. However, this core engine originally started out as part of a SharePoint based product with a fixed number of hardcoded converters. The SharePoint user interface retrieves the list of converters via the GetConfiguration Web Service call and locally stores some settings against each converter. The same user interface uses the GetDiagnostics method on one or more converters to see if everything has been installed and configured correctly.

Configuration / Diagnostics related classes

The change

Both the GetConfiguration and GetDiagnostics methods return objects that used to contain a ConverterType property, which holds an element of the following enumeration:

    private enum ConverterType
    {
        WordProcessing,
        SpreadSheets,
        Presentations,
        InfoPath,
        Vector,
        OneNote,
        MicrosoftPublisher,
        HTML
    }

As it is now possible to add custom converters to the conversion engine, we can no longer rely on a fixed list of converters. As a result we have dropped the ConverterType property in favour of the new ConverterName property, which holds a string that identifies the converter. This identifier is identical to the key field used by the config file to describe the converter.

In addition to this change we have also dropped the ConversionFidelity property from the DiagnosticRequestItem. This value is now read from the config file for the specified ConverterName.

We are fairly confident that very few people are using these specific interfaces. However, if you are and you need further information or assistance then please let us know.

Using the PDF Watermarking features from Java based environments

2010-06-11T11:20:00.001+01:00

As an ever increasing number of customers are using our PDF Conversion Services from Java based environments we have decided to make our sample code and tutorials available in Java in addition to C# / .NET. Have a look at this post for an introduction to using the PDF Conversion Web Services from Java based environments.

The C# / .net version of this post ‘Using the awesome new watermarking features of the Muhimbi PDF Converter Services’ provides a good introduction to the watermarking capabilities of our PDF Conversion products. I recommend reading it, even if you know nothing about C#, as the fundamental principles and object model are exactly the same.

The Muhimbi Document Conversion Service contains a very flexible system for applying watermarks to documents. Multiple watermarks can be applied to the same page and watermarks can be applied to page ranges or certain page types such as odd,even, portrait or landscape. In addition you can add field codes such as {PAGE} and {NUMPAGES} to dynamically add page numbers, headers and footers to PDF documents.

Watermarks are passed as part of the ConversionSettings object, a parameter of the Convert method. An overview of the watermarking related Web Services interface is provided below. For full details see the full User & Developer Guide.

The following Java based sample code is identical to a previous sample, with the exception that the Watermarks property in the ConversionSettings class is populated with a simple watermark that prints the word ‘Confidential’ on the front page in combination with the current date. Note that this sample code is automatically installed with the conversion service.

For details on how to setup your Java environment and generate the Web Service proxies see this post.

package com.muhimbi.app;               
              
import com.muhimbi.ws.*;               
import java.io.*;               
import java.net.URL;               
import java.util.List;               
import javax.xml.bind.JAXBElement;               
import javax.xml.namespace.QName;               
              
public class WsClient {               
              
  private final static String DOCUMENTCONVERTERSERVICE_WSDL_LOCATION =               
        "http://localhost:41734/Muhimbi.DocumentConverter.WebService/?wsdl";               
              
  public static void main(String[] args) {               
    try {               
      if (args.length != 1) {               
        System.out.println("Please specify a single file name on the command line.");  
      } else {               
        // ** Process command line parameters               
        String sourceDocumentPath = args[0];               
        File file = new File(sourceDocumentPath);               
        String fileName = getFileName(file);               
        String fileExt = getFileExtension(file);               
              
        System.out.println("Converting file " + sourceDocumentPath);               
              
        // ** Initialise Web Service               
        DocumentConverterService_Service dcss = new DocumentConverterService_Service(               
            new URL(DOCUMENTCONVERTERSERVICE_WSDL_LOCATION),               
            new QName("http://tempuri.org/", "DocumentConverterService"));               
        DocumentConverterService dcs = dcss.getBasicHttpBindingDocumentConverterService();               
              
        // ** Only call conversion if file extension is supported               
        if (isFileExtensionSupported(fileExt, dcs)) {               
          // ** Read source file from disk               
          byte[] fileContent = readFile(sourceDocumentPath);               
              
          // ** Converting the file               
          OpenOptions openOptions = getOpenOptions(fileName, fileExt);               
          ConversionSettings conversionSettings = getConversionSettings();               
          byte[] convertedFile = dcs.convert(fileContent, openOptions, conversionSettings);               
              
          // ** Writing converted file to file system               
          String destinationDocumentPath = getPDFDocumentPath(file);               
          writeFile(convertedFile, destinationDocumentPath);               
          System.out.println("File converted sucessfully to " + destinationDocumentPath);               
              
        } else {               
          System.out.println("The file extension is not supported.");               
        }               
      }               
              
    } catch (IOException e) {               
      System.out.println(e.getMessage());               
    } catch (DocumentConverterServiceGetConfigurationWebServiceFaultExceptionFaultFaultMessage e) {               
      printException(e.getFaultInfo());               
    } catch (DocumentConverterServiceConvertWebServiceFaultExceptionFaultFaultMessage e) {               
      printException(e.getFaultInfo());               
    }               
  }               
              
  public static OpenOptions getOpenOptions(String fileName, String fileExtension) {               
    ObjectFactory objectFactory = new ObjectFactory();               
    OpenOptions openOptions = new OpenOptions();               
    // ** Set the minimum required open options. Additional options are available               
    openOptions.setOriginalFileName(objectFactory.createOpenOptionsOriginalFileName(fileName));               
    openOptions.setFileExtension(objectFactory.createOpenOptionsFileExtension(fileExtension));               
    return openOptions;               
  }               
              
  public static ConversionSettings getConversionSettings() {               
    ConversionSettings conversionSettings = new ConversionSettings();               
    // ** Set the minimum required conversion settings. Additional settings are available               
    conversionSettings.setQuality(ConversionQuality.OPTIMIZE_FOR_PRINT);               
    conversionSettings.setRange(ConversionRange.ALL_DOCUMENTS);               
    conversionSettings.getFidelity().add("Full");               
    conversionSettings.setFormat(OutputFormat.PDF);               
    conversionSettings.setWatermarks(getWatermarks());               
    return conversionSettings;               
  }               
              
  public static JAXBElement<ArrayOfWatermark> getWatermarks()               
  {               
    ObjectFactory objectFactory = new ObjectFactory();               
    ArrayOfWatermark watermarks = new ArrayOfWatermark();               
              
    // ** Specify some of the default settings for properties               
    Defaults wmDefaults = new Defaults();               
    wmDefaults.setFillColor(objectFactory.createDefaultsFillColor("#FF0000"));               
    wmDefaults.setFontFamilyName(objectFactory.createDefaultsFontFamilyName("Arial"));               
              
    // ** 'Confidential' watermark for front page               
    Watermark confidential = new Watermark();               
    confidential.setDefaults(objectFactory.createContainerDefaults(wmDefaults));               
    confidential.setStartPage(1);               
    confidential.setEndPage(1);               
    confidential.setRotation(objectFactory.createElementRotation("-15"));               
    confidential.setWidth(objectFactory.createElementWidth("500"));               
    confidential.setHeight(objectFactory.createElementHeight("250"));               
    confidential.setHPosition(HPosition.CENTER);               
    confidential.setVPosition(VPosition.ABSOLUTE);               
    confidential.setY(objectFactory.createElementY("275"));               
    confidential.setZOrder(-1);               
              
    // ** Create a new Text element that goes inside the watermark               
    Text cfText = new Text();               
    cfText.setContent(objectFactory.createTextContent("Confidential - {DATE}"));               
    cfText.setFontSize(objectFactory.createTextFontSize("40"));               
    cfText.getFontStyle().add("Bold");               
    cfText.getFontStyle().add("Italic");               
    cfText.setWidth(objectFactory.createElementWidth("500"));               
    cfText.setHeight(objectFactory.createElementHeight("250"));               
    cfText.setTransparency(objectFactory.createElementTransparency("0.10"));               
              
    // ** And add it to the list of watermark elements.               
    ArrayOfElement cfElements = new ArrayOfElement();               
    cfElements.getElement().add(cfText);               
    confidential.setElements(objectFactory.createContainerElements(cfElements));               
              
    // ** And add the watermark to the list of watermarks               
    watermarks.getWatermark().add(confidential);               
              
    return objectFactory.createConversionSettingsWatermarks(watermarks);               
  }               
                
  public static String getFileName(File file) {               
    String fileName = file.getName();               
    return fileName.substring(0, fileName.lastIndexOf('.'));               
  }               
              
  public static String getFileExtension(File file) {               
    String fileName = file.getName();               
    return fileName.substring(fileName.lastIndexOf('.') + 1, fileName.length());               
  }               
              
  public static String getPDFDocumentPath(File file) {               
    String fileName = getFileName(file);               
    String folder = file.getParent();               
    if (folder == null) {               
      folder = new File(file.getAbsolutePath()).getParent();               
    }               
    return folder + File.separatorChar + fileName + '.' + OutputFormat.PDF.value();               
  }               
              
  public static byte[] readFile(String filepath) throws IOException {               
    File file = new File(filepath);               
    InputStream is = new FileInputStream(file);               
    long length = file.length();               
    byte[] bytes = new byte[(int) length];               
              
    int offset = 0;               
    int numRead;               
    while (offset < bytes.length && (numRead = is.read(bytes, offset, bytes.length - offset)) >= 0) {               
      offset += numRead;               
    }               
              
    if (offset < bytes.length) {               
      throw new IOException("Could not completely read file " + file.getName());               
    }               
    is.close();               
    return bytes;               
  }               
              
  public static void writeFile(byte[] fileContent, String filepath) throws IOException {               
    OutputStream os = new FileOutputStream(filepath);               
    os.write(fileContent);               
    os.close();               
  }               
              
  public static boolean isFileExtensionSupported(String extension, DocumentConverterService dcs)               
    throws DocumentConverterServiceGetConfigurationWebServiceFaultExceptionFaultFaultMessage               
    {               
      Configuration configuration = dcs.getConfiguration();               
      final JAXBElement<ArrayOfConverterConfiguration> converters = configuration.getConverters();               
      final ArrayOfConverterConfiguration ofConverterConfiguration = converters.getValue();               
      final List<ConverterConfiguration> cList = ofConverterConfiguration.getConverterConfiguration();               
                
      for (ConverterConfiguration cc : cList) {               
        final List<String> supportedExtension = cc.getSupportedFileExtensions().getValue().getString();               
        if (supportedExtension.contains(extension)) {               
          return true;               
        }               
    }               
              
    return false;               
  }               
              
  public static void printException(WebServiceFaultException serviceFaultException) {               
    System.out.println(serviceFaultException.getExceptionType());               
    JAXBElement<ArrayOfstring> element = serviceFaultException.getExceptionDetails();               
    ArrayOfstring value = element.getValue();               
    for (String msg : value.getString()) {               
      System.out.println(msg);               
    }               
  }               
              
}

Using the awesome new watermarking features of the Muhimbi PDF Converter Services

2010-06-09T14:54:00.001+01:00

As I mentioned in a previous post about adding your own converters using our fancy new plug-in architecture, we prioritise new functionality based on the number of customers requesting a particular feature. The feature I will be discussing today is one that has been on our radar for a long time, Watermarking.

We have previously provided some sample code to watermark documents using our Workflow Power Pack and although that solution is working well for many of our customers, it was only an interim solution that doesn’t come close to providing the functionality in our new watermarking engine, which is totally awesome

Note that at this moment we have only added native support for watermarking to the back-end conversion engine. Although it can be accessed using the Workflow Power Pack, we have not yet released a dedicated Workflow Action to control watermarking from SharePoint, which will be released in the next version.

Right, so back to the topic at hand. Listed below is an overview of our new Watermarking architecture as well as some sample code. More information and a full description of the object model can be found in the PDF Converter Services’ comprehensive User & Developer Guide. Note that you need version 3.5 or newer to make use of the new watermarking functionality.

Individual Element Types

As all individual elements / shapes inherit from the Element class, they largely share the same properties.

The supported element types are as follows.

Line: Represents a single line.
Rectangle: Represents a rectangle..
Ellipse: Represents an ellipse.
Rtf: Represents a piece of text encoded in RTF format.
Image: Represents an image. The following image types are supported: BMP, JPG, GIF, PNG, TIFF, WMF, EMF and EMF+.
Pdf: Represents an existing PDF file that is used as the watermark.
Text: Represents a text box that allows plain text to be specified with full control over horizontal and vertical alignment, font face and size as well as word wrapping. This field also allows field codes such as page number to be embedded (see below).

Embedding field codes in the Text element

The Text element allows field codes to be embedded such as the number of pages or the current date. This makes it very simple to use watermarks to automatically generate headers and footers on each page, while taking orientation and page interval (Odd / Even pages) into account.

The following field codes are available for use:

{LONG_DATE}: The long representation of the current date.
{LONG_TIME}: The long representation of the current time.
{DATE}: The short representation of the current date.
{TIME}: The short representation of the current time.
{PAGE}: The number of the current page in the PDF file.
{NUMPAGES}: The total number of pages in the PDF file.

Date and time fields are formatted using the locale used by the account the Document Conversion Service is running under.

Sample Code

As described previously, the PDF Conversion Service contains a powerful watermarking engine that can be used to add visible and invisible watermarks to pages as well as adding headers, footers and other recurring items.

The following C# example (Java sample available here) shows how to decorate a document with the following watermarks:

Add the word ‘Confidential’ in the background of the cover page.
Add page numbers in the right-hand side of the footer as well as a horizontal line to all even pages.
Add page numbers in the left-hand side of the footer as well as a horizontal line to all odd pages.

The sample code expects the path of the PDF file on the command line. If the path is omitted then the first MS-Word file found in the current directory will be used.

Follow the steps described below to create the sample watermarking application. Please note that this sample code is also available via the Windows Start Menu.

Create a new Visual Studio C# Console application named Watermarking.
Add a Service Reference to the following URL and specify ConversionService as the namespace

http://localhost:41734/Muhimbi.DocumentConverter.WebService/?wsdl

Paste the following code into Program.cs.

using System;

using System.Collections.Generic;

using System.Diagnostics;

using System.IO;

using System.ServiceModel;

using Watermarking.ConversionService;

namespace Watermarking

    class Program

     // ** The URL where the Web Service is located. Amend host name if needed.

     static string SERVICE_URL = "http://localhost:41734/Muhimbi.DocumentConverter.WebService/";

        static void Main(string[] args)

            DocumentConverterServiceClient client = null;

try

                // ** Determine the source file and read it into a byte array.

                string sourceFileName = null;

                if (args.Length == 0)

                    string[] sourceFiles = Directory.GetFiles(
                                                   Directory.GetCurrentDirectory(), "*.doc");

                    if (sourceFiles.Length > 0)

                        sourceFileName = sourceFiles[0];

                    else

                       Console.WriteLine("Please specify a document to convert and watermark.");

                       Console.ReadKey();

                       return;

                else

                    sourceFileName = args[0];

                byte[] sourceFile = File.ReadAllBytes(sourceFileName);

                // ** Open the service and configure the bindings

                client = OpenService(SERVICE_URL);

                //** Set the absolute minimum open options

                OpenOptions openOptions = new OpenOptions();

                openOptions.OriginalFileName = Path.GetFileName(sourceFileName);

                openOptions.FileExtension = Path.GetExtension(sourceFileName);

                // ** Set the absolute minimum conversion settings.

                ConversionSettings conversionSettings = new ConversionSettings();

                conversionSettings.Fidelity = ConversionFidelities.Full;

                conversionSettings.Quality = ConversionQuality.OptimizeForPrint;

                // ** Get the list of watermarks to apply.

                conversionSettings.Watermarks = CreateWatermarks();

                // ** Carry out the conversion.

                Console.WriteLine("Converting file " + sourceFileName);

                byte[] convFile = client.Convert(sourceFile, openOptions, conversionSettings);

                // ** Write the converted file back to the file system with a PDF extension.

                string destinationFileName = Path.GetDirectoryName(sourceFileName) + @"\" +

                                             Path.GetFileNameWithoutExtension(sourceFileName) +

                                             "." + conversionSettings.Format;

                using (FileStream fs = File.Create(destinationFileName))

                    fs.Write(convFile, 0, convFile.Length);

                    fs.Close();

                Console.WriteLine("File converted to " + destinationFileName);

                // ** Open the generated PDF file in a PDF Reader

                Process.Start(destinationFileName);

            catch (FaultException<WebServiceFaultException> ex)

                Console.WriteLine("FaultException occurred: ExceptionType: " +

                                 ex.Detail.ExceptionType.ToString());

            catch (Exception ex)

                Console.WriteLine(ex.ToString());

            finally

                CloseService(client);

            Console.ReadKey();

        /// <summary>

        /// Create the watermarks.

        /// </summary>

        /// <returns>An array of watermarks to apply</returns>

        public static Watermark[] CreateWatermarks()

            List<Watermark> watermarks = new List<Watermark>();

            // ** Specify the default settings for properties

            Defaults wmDefaults = new Defaults();

            wmDefaults.FillColor = "#000000";

            wmDefaults.LineColor = "#000000";

            wmDefaults.FontFamilyName = "Arial";

            wmDefaults.FontSize = "10";

            // **************** 'Confidential' Text ***************

            // ** 'Confidential' watermark for front page

            Watermark confidential = new Watermark();

            confidential.Defaults = wmDefaults;

            confidential.StartPage = 1;

            confidential.EndPage = 1;

            confidential.Rotation = "-45";

            confidential.Width = "500";

            confidential.Height = "500";

            confidential.HPosition = HPosition.Center;

            confidential.VPosition = VPosition.Middle;

            confidential.ZOrder = -1;

            // ** Create a new Text element that goes inside the watermark

            Text cfText = new Text();

            cfText.Content = "Confidential";

            cfText.FontSize = "40";

            cfText.FontStyle = FontStyle.Bold | FontStyle.Italic;

            cfText.Width = "500";

            cfText.Height = "500";

            cfText.Transparency = "0.10";

            // ** And add it to the list of watermark elements.

            confidential.Elements = new Element[] { cfText };

            // ** And add the watermark to the list of watermarks

            watermarks.Add(confidential);

            // **************** Watermark for Odd pages ***************

            Watermark oddPages = new Watermark();

            oddPages.Defaults = wmDefaults;

            oddPages.StartPage = 3;

            oddPages.PageInterval = 2;

            oddPages.Width = "600";

            oddPages.Height = "50";

            oddPages.HPosition = HPosition.Right;

            oddPages.VPosition = VPosition.Bottom;

            // ** Add a horizontal line

            Line line = new Line();

            line.X = "1";

            line.Y = "1";

            line.EndX = "600";

            line.EndY = "1";

            line.Width = "5";

            // ** Add a page counter

            Text oddText = new Text();

            oddText.Content = "Page: {PAGE} of {NUMPAGES}";

            oddText.Width = "100";

            oddText.Height = "20";

            oddText.X = "475";

            oddText.Y = "15";

            oddText.LineWidth = "-1";

            oddText.FontStyle = FontStyle.Regular;

            oddText.HAlign = HAlign.Right;

            // ** And add it to the list of watermark elements

            oddPages.Elements = new Element[] { line, oddText };

            // ** And add the watermark to the list of watermarks

            watermarks.Add(oddPages);

            // **************** Watermark for Even pages ***************

            Watermark evenPages = new Watermark();

            evenPages.Defaults = wmDefaults;

            evenPages.StartPage = 2;

            evenPages.PageInterval = 2;

            evenPages.Width = "600";

            evenPages.Height = "50";

            evenPages.HPosition = HPosition.Left;

            evenPages.VPosition = VPosition.Bottom;

            // ** No need to create an additional line,re-use the previous one

            // ** Add a page counter

            Text evenText = new Text();

            evenText.Content = "Page: {PAGE} of {NUMPAGES}";

            evenText.Width = "100";

            evenText.Height = "20";

            evenText.X = "25";

            evenText.Y = "15";

            evenText.LineWidth = "-1";

            evenText.FontStyle = FontStyle.Regular;

            evenText.HAlign = HAlign.Left;

            // ** And add it to the list of watermark elements

            evenPages.Elements = new Element[] { line, evenText };

            // ** And add the watermark to the list of watermarks

            watermarks.Add(evenPages);

            return watermarks.ToArray();

        /// <summary>

        /// Configure the Bindings, endpoints and open the service using the specified address.

        /// </summary>

        /// <returns>An instance of the Web Service.</returns>

        public static DocumentConverterServiceClient OpenService(string address)

            DocumentConverterServiceClient client = null;

try

                BasicHttpBinding binding = new BasicHttpBinding();

                // ** Use standard Windows Security.

                binding.Security.Mode = BasicHttpSecurityMode.TransportCredentialOnly;

                binding.Security.Transport.ClientCredentialType =

                                                              HttpClientCredentialType.Windows;

                // ** Increase the client Timeout to deal with (very) long running requests.

                binding.SendTimeout = TimeSpan.FromMinutes(30);

                binding.ReceiveTimeout = TimeSpan.FromMinutes(30);

                // ** Set the maximum document size to 50MB

                binding.MaxReceivedMessageSize = 50 * 1024 * 1024;

                binding.ReaderQuotas.MaxArrayLength = 50 * 1024 * 1024;

                binding.ReaderQuotas.MaxStringContentLength = 50 * 1024 * 1024;

                // ** Specify an identity (any identity) in order to get it past .net3.5 sp1

                EndpointIdentity epi = EndpointIdentity.CreateUpnIdentity("unknown");

                EndpointAddress epa = new EndpointAddress(new Uri(address), epi);

                client = new DocumentConverterServiceClient(binding, epa);

                client.Open();

                return client;

            catch (Exception)

                CloseService(client);

                throw;

        /// <summary>

        /// Check if the client is open and then close it.

        /// </summary>

        /// <param name="client">The client to close</param>

        public static void CloseService(DocumentConverterServiceClient client)

            if (client != null && client.State == CommunicationState.Opened)

                client.Close();

Make sure the output folder contains an MS-Word file.
Compile and execute the application.

As all this functionality is exposed via a Web Services interface, it works equally well from Java and other web services enabled environments.

This code is merely an example of what is possible, feel free to adapt it to you own needs, add more complex watermarks or your company logo to each page. The possibilities are endless.

Adding custom Converters to Muhimbi’s range of PDF Conversion products

2010-06-03T12:13:00.003+01:00

At Muhimbi we are continuously improving our range of PDF Conversion products such as the PDF Converter for SharePoint and the Muhimbi PDF Converter Services. The way we prioritise new features is simple, we take the list of our customers’ feature requests, order it by number of times requested and we develop away. It really is that simple.

We recently delivered our #1 feature request, which is compatibility with SharePoint 2010 and Office 2010. Next up is native support for watermarking (more about that in a future post) and the ability for our customers to add custom converters that fit their exact needs. This post provides an example of how to create your own Custom Converter and add it to the Document Conversion Service. Note that you need version 3.5 or newer to make use of custom converters.

The Muhimbi PDF Conversion Service allows custom converters to be added with relative ease. This is useful for converting file types specific to your organisation or for file types that have not (yet) been implemented by Muhimbi in the main product.
The following example shows how to replace the existing MS-Word converter, which relies on MS-Word being present, with a simple third party converter that works well enough for simple documents. Some programming knowledge is required.

The steps are as follows:

Create a new Visual Studio project, select Class Library (C#, .net 3.0) as the template and give the project an appropriate name, e.g. CustomConverters.
Add references to the following DLLs. They are located in the folder the Muhimbi Document Conversion Service has been installed in, usually c:\Program Files\Muhimbi….

•    Muhimbi.dll
•    Muhimbi.DocumentConverter.WebService.dll
•    Muhimbi.DocumentConverter.WebService.Data.dll
•    System.Runtime.Serialization (Add reference from the .NET tab, you can’t ‘Browse’ for this DLL)
Change your project’s Assembly name and default namespace to something sensible, e.g. Muhimbi.DocumentConverter.WebService.CustomConverters. This can be done by right-clicking on your project and selecting Properties. The Application tab allows these settings to be changed.
Delete the automatically generated class1.cs file and add a new class named WordConverter.cs. Make sure the class definition is public.
Inherit Muhimbi.DocumentConverter.WebService.AbstractDocumentConverter in the WordConverter class and implement the members (right-click on the base class name and select Implement Abstract Class).

Add the following 2 constructors and make sure they call the base constructors.

public WordConverter()

    : base()

{ }

public WordConverter(Stream sourceFile, OpenOptions openOptions,

                     ConversionSettings conversionSettings)

    : base(sourceFile, openOptions, conversionSettings)

{ }

Next up, we need to implement the RunDiagnostics method. This method is normally used to carry out an internal end-to-end conversion to verify that the converter and all prerequisites have been installed correctly. In this test we simply return a new DiagnosticResultItem with the Valid property set to true.
```
public override DiagnosticResultItem RunDiagnostics()
```
```
{
```
```
    DiagnosticResultItem dri = new DiagnosticResultItem();
```
```
    dri.Valid = true;
```
```
    return dri;
```
```
}
```

If we need to look further than just the file extension to determine the file type then we can optionally override the CanConvert method and look inside the stream (available in the _sourceFile member variable). This is not necessary for this sample converter, but an example is provided below.

public override bool CanConvert(string[] fileExtensions)

   // ** Do we know anything about this extension

   if (base.CanConvert(fileExtensions) == false)

       return false;

   // ** Investigate in more detail

   ...implement your own...

The next and final method to implement is the actual Convert method, which is where all the magic happens. As it is not feasible to develop an MS-Word to PDF converter from scratch, the sensible thing to do is to use a third party library such as SyncFusion DocIO or Aspose.Words (download the archive that contains just the DLLs). In this example we are going to use Aspose's library for processing MS-Word files. It is not perfect, but for some documents such as forms and simple text documents it works very well.

Copy Aspose.Words.dll into the project directory and add a reference to it. Copy the following code into the WordConverter class.

public override Stream Convert()

try

        // ** Validate as certain options are not supported by this converter

        if (_openOptions.AllowMacros != MacroSecurityOption.None)

            Logger.Warn("Macros are not supported by this converter.");

        // ** Set the licences for Aspose.Words.

        Aspose.Words.License wordLicence = new Aspose.Words.License();

        //wordLicence.SetLicense("Enter your license in here.");

        Document asposeDocument = new Document(_sourceFile, null,

                                       LoadFormat.Auto, _openOptions.Password);

        // ** Do we need to refresh the fields etc?

        if (_openOptions.RefreshContent == true)

            asposeDocument.Range.UpdateFields();

        // ** Convert the Document to PDF and save it as a memory stream.

        if (_conversionSettings.Format == OutputFormat.PDF)

            MemoryStream convertedStream = new MemoryStream();

            PdfOptions options = new PdfOptions();

            // ** Specify the PDF Profile

            if (_conversionSettings.PDFProfile == PDFProfile.PDF_1_5)

                options.Compliance = PdfCompliance.Pdf15;

            else

                options.Compliance = PdfCompliance.PdfA1b;

            // ** How to deal with bookmarks

            if (_conversionSettings.GenerateBookmarks == BookmarkGenerationOption.Automatic)

                options.HeadingsOutlineLevels = 9;

            else if (_conversionSettings.GenerateBookmarks == BookmarkGenerationOption.Custom)

                options.BookmarksOutlineLevel = 9;

            // ** Correct the start and end pages if needed

            int startPage = _conversionSettings.StartPage != 0 ?

                            _conversionSettings.StartPage - 1 : 0;

            int pageCount = asposeDocument.PageCount - startPage;

            if (_conversionSettings.EndPage != 0)

                pageCount = Math.Min(_conversionSettings.EndPage - startPage, pageCount);

            // ** Carry out the actual conversion

            asposeDocument.SaveToPdf(startPage, pageCount, convertedStream, options);

            return convertedStream;

        else

            throw new NotSupportedException("Outputformat '" + _conversionSettings.Format +

                                        "' not supported by this Converter.");

    catch (UnsupportedFileFormatException ex)

        throw new WebServiceInternalException(

            WebServiceExceptionType.FileFormatNotSupported, ex.Message);

    catch (Exception ex)

        string message = "An error occurred while converting a file";

        if (_openOptions != null && _openOptions.OriginalFileName != null)

            message += " - " + _openOptions.OriginalFileName;

        Logger.Error(message, ex);

        throw new WebServiceInternalException(WebServiceExceptionType.InternalError, message);

Compile the project and copy the output DLL as well as Aspose.Words.dll to the directory that holds the Muhimbi Document Conversion Service.

Edit the service's config file and make the following changes:

•    If the file extensions for the new converter are currently handled by a different converter then remove these extensions
     from the existing converter.

•    Add the definition for the new converter to the config file as per the following example.

<add key="CustomWordConverter"

     description="Custom MS-Word Converter"

     fidelity="Full"

     supportedExtensions="doc,docx"

     type="Muhimbi.DocumentConverter.WebService.CustomConverters.WordConverter,

     Muhimbi.DocumentConverter.WebService.CustomConverters,

     Version=1.0.0.0, Culture=neutral, PublicKeyToken=null" />

Restart the service to activate the changes.

Net stop "Muhimbi Document Converter Service"
Net start "Muhimbi Document Converter Service"
Finally test if everything is working correctly, either from:

•   SharePoint: Open Central Administration / Application Management / Muhimbi Document Converter Settings, verify
     that the new converter is added to the list, check the tick box and click Validate Settings. If everything is working
     correctly then don’t forget to save the changes using the OK button.

•   Winforms Diagnostics Tool: Launch the Diagnostics Tool from the Windows Start Menu, navigate to the WS Diagnose
     Tab and click the Request Diagnostics button. Verify the new converter is listed and Valid = True.

Any errors are logged to the Windows Application Event Log.

Congratulations, you have created your first custom converter. The source code for the WordConverter.cs class can be downloaded here.

Exception handling

Although you can let exceptions bubble up, we recommend catching any exceptions, looking at the root cause of the problem and then throw a specific WebServiceInternalException using one of the following exception types.

public enum WebServiceExceptionType
{
    /// <summary>
    /// Unknown error
    /// </summary>
    Unknown,
    /// <summary>
    /// File format not supported
    /// </summary>
    FileFormatNotSupported,
    /// <summary>
    /// File corrupt
    /// </summary>
    CorruptDocument,
    /// <summary>
    /// An error occurred while opening the file
    /// </summary>
    ErrorOpeningFile,
    /// <summary>
    /// Conversion process timeout
    /// </summary>
    ConversionTimeOut,
    /// <summary>
    /// Application hang. Can happen when document is password protected
    /// </summary>
    ConverterNotResponding,
    /// <summary>
    /// The underlying converter has not been installed or not correctly installed.
    /// </summary>
    ConverterNotInstalled,
    /// <summary>
    /// Internal Validation (Should only happen during development)
    /// </summary>
    InternalError
}

Combining multiple PDF files using a SharePoint Designer Workflow

2010-05-26T23:23:00.001+01:00

Hi I’m Nicolas and today I will show how to merge multiple PDF files using a SharePoint Designer workflow using the PDF Converter for SharePoint and the Workflow Power Pack.

A quick introduction for those not familiar with the product: The Muhimbi Workflow Power Pack for SharePoint allows custom C# or VB.NET code to be embedded in SharePoint Designer Workflows without the need to resort to complex Visual Studio based workflows, the development of bespoke Workflow Activities or long development cycles.

The solution presented below shows how to create a SharePoint Designer workflow and attach it to a document library. This workflow is triggered when adding or modifying an item in the library, for example after converting a document using the PDF Converter. This example is particularly useful when you want to automatically add a cover page or Appendix to each and every PDF file in the system.

The workflow checks if the file extension for the current item is “pdf”. If this is the case then it uses the Workflow Power Pack to execute some C# code that carries out the actual appending of PDF files. The solution provided in this post works in SharePoint 2007 as well as 2010.

Create the workflow as follows:

Download and install the Muhimbi Workflow Power Pack for SharePoint
Download and install the Muhimbi PDF Converter for SharePoint
We need to be able to access functionality in the Muhimbi.SharePoint.DocumentConverter.PDF assembly. Add this reference to the relevant Web Application using the Workflow Power Pack Central Administration screens as described in the Administration Guide.
Make sure you have the appropriate privileges to create workflows on a site collection.
Create a new workflow using SharePoint Designer.
On the Workflow definition screen associate the workflow with the Shared Documents library, tick the boxes next to both “Automatically start….” options and proceed to the next screen.
We only want to act on files of type PDF. Although we could have put this validation in the code, in this example we use a workflow condition for it so add a Compare Any Data Source condition and:

a. Click on the first value followed by the display data binding (fx) button.
b. Select Current Item as the Source and select File Type in the Field. Click the OK button to continue.
c. Click on the second value and enter pdf. (Use lower case as the compare option is case sensitive).
Click the Actions button and insert the Execute Custom Code action.
Click parameter 1 and enter a relative or absolute path to the PDF file you want to append to the current workflow item. For example /sites/PDFConversion/Shared%20Documents/appendix.pdf or Shared%20Documents/appendix.pdf
Optionally, click parameter 2 to specify a second PDF file to append.

Insert the C# based code listed below by clicking this code in the workflow designer. Note that copying this code using Internet Explorer may remove line breaks. Preferably use Chrome or Firefox to copy the code or alternatively paste it from Internet Explorer into Windows Wordpad and then copy it from there into SharePoint Designer.

/*********************************************************************************************

                     Muhimbi PDF Converter - Combining Multiple PDF Files

              Copyright 2010, Muhimbi Ltd - www.muhimbi.com - All rights reserved

The following code shows a simple way to merge PDF content from one or more files.

Error and permission checking as well as other minor features have been omitted for the sake

of brevity and clarity.

This code requires Muhimbi’s PDF Converter and Workflow Power Pack to be installed.

**********************************************************************************************/

using Syncfusion.Pdf.Parsing;

using System.IO;

// ** Some variables we're going to use

SPFile spDocument1ToAppend = null;

SPFile spDocument2ToAppend = null;

PdfLoadedDocument document1ToAppend = null;

PdfLoadedDocument document2ToAppend = null;

// ** Get and load current pdf document (the one which triggered the workflow)

SPFile spSourceDocument = MyWorkflow.Item.File;

PdfLoadedDocument sourcePdfDocument = new PdfLoadedDocument(spSourceDocument.OpenBinary());

// ** If supplied, get and load 1st pdf document to append to

string document1ToAppendPath = MyWorkflow.Parameter1 as string;

if (!string.IsNullOrEmpty(document1ToAppendPath))

    spDocument1ToAppend = MyWorkflow.Web.GetFile(document1ToAppendPath);

    document1ToAppend = new PdfLoadedDocument(spDocument1ToAppend.OpenBinary());

// ** If supplied, get and load 2nd pdf document to append to

string document2ToAppendPath = MyWorkflow.Parameter2 as string;

if (!string.IsNullOrEmpty(document2ToAppendPath))

    spDocument2ToAppend = MyWorkflow.Web.GetFile(document2ToAppendPath);

    document2ToAppend = new PdfLoadedDocument(spDocument2ToAppend.OpenBinary());

// ** Get destination file and folder

string destinationFolderUrl = spSourceDocument.ParentFolder.Url;

SPFolder spDestinationFolder = MyWorkflow.Web.GetFolder(destinationFolderUrl);

string destinationFileName = spSourceDocument.Name;

string destinationFilePath = string.Format("{0}/{1}", destinationFolderUrl,
                             destinationFileName);

SPWeb spDestinationWeb = spDestinationFolder.ParentWeb;

SPFile spDestinationFile = spDestinationWeb.GetFile(destinationFilePath);

// ** If a document library requires manual checkout and the file is not checked out,

// ** then check the file out before uploading

if (spDestinationFile.Exists && spDestinationFile.Item.ParentList.ForceCheckout &&

    spDestinationFile.CheckOutStatus == SPFile.SPCheckOutStatus.None)

    spDestinationFile.CheckOut();

// ** Add the file to the site including the meta data

using (MemoryStream mergedDocument = new MemoryStream())

    // ** Append files to destination document

    if (document1ToAppend != null)

        sourcePdfDocument.Append(document1ToAppend);

    if (document2ToAppend != null)

        sourcePdfDocument.Append(document2ToAppend);

    // ** Save merged file and overwrite in document library

    sourcePdfDocument.Save(mergedDocument);

    spDestinationFile = spDestinationWeb.Files.Add(destinationFilePath, mergedDocument,
                        spSourceDocument.Item.Properties, true);

// ** Check the file back in if this script was responsible for checking it out

if (spDestinationFile.Item.ParentList.ForceCheckout)

    spDestinationFile.CheckIn("Auto check-in after PDF document appending.");

Click the Actions button, select Log to History List, click this message and enter PDF content appended to current item.
Close the Workflow Designer.
Update an existing PDF or add a new PDF file to your document library to trigger the workflow and append contents from the files defined in parameter 1 and parameter 2.
The workflow should look something like this.

Of course this is just a sample, feel free to play around with the code, change which parameters are passed into the workflow, use different document libraries as source and destination of PDF documents, change the sequence in which documents are appended, etc.

Please leave a comment if you’re trying to do anything specific or if you want to share your experience with this approach.

As always, feel free to contact us using Twitter, our Blog, regular email or subscribe to our newsletter.

Workflow Power Pack 1.2 - Embed C#/VB in SharePoint 2007 / 2010 Designer Workflows

2010-05-24T11:57:00.001+01:00

If you are a loyal follower of this blog then you may have noticed that we are adding SharePoint 2010 compatibility to our entire Product Line. We started with our best-selling PDF Converter for SharePoint and, with the experience gained during that project, moved on to the Workflow Power Pack.

In addition to SharePoint 2010 support we have also made it possible to localise the Workflow Power Pack for the non-English market. Support for the Dutch language has already been added and more languages will follow shortly. If you would like to see support for your language then please drop us a line.

Look at the fancy support for the Shiny new SharePoint Designer 2010 Workflow Editor

The main changes in version 1.2 are as follows:

859	Added support for SharePoint 2010.
723	Made it possible to create localised versions.
862	Added support for the Dutch language.
856	Added support for Server and Enterprise license models.
858	Improved support for deploying resource files in Farm environments.

For more information check out the following resources:

As always, feel free to contact us using Twitter, our Blog, regular email or subscribe to our newsletter.

Download your free trial here (1.5MB).

New release of MuSH – Workflow Enabled ‘TinyURL’ for SharePoint v2

2010-05-07T15:43:00.001+01:00

Today we are releasing a small and incremental upgrade to the Muhimbi URL Shortener for SharePoint. No major new features, just bug fixes, deployment improvements and changes to the License Manager to manage our new type of Server and Enterprise licenses. Oh the excitement….

For those not familiar with the product, the Muhimbi URL Shortener for SharePoint, aka MuSH, can be used to shorten URLs for typical web applications and SharePoint in particular. It integrates tightly with both WSS and MOSS and allows short URLs to be created directly from a list item’s context menu, workflows and web services. For details see the original announcement.

The main changes and improvements are as follows:

848	Error when first ever shortened URL is given a manual short name. If you deployed a previous version and experienced problems then please contact use before downloading this new version as some manual steps are involved. This only affects a small number of users.
852	Added support for new licensing model.
854	Added new resource deployment libraries.

For more information check out the:

As always, feel free to contact us using Twitter, our Blog or regular email or subscribe to our newsletter.

Download your free trial here (1MB).

PDF Converter for SharePoint 3.4 – SharePoint 2010 & Office 2010 RTM Compatible

2010-05-06T15:58:00.001+01:00

Although it has only been 2 weeks since the RTM version of SharePoint 2010 was released, our team has been working flat out to make the popular Muhimbi PDF Converter for SharePoint compatible with both SharePoint 2007 and SharePoint 2010.

As we were going through a full QA cycle anyway we also validated the software with the RTM version of Office 2010 to make sure our customers can make use of the latest and greatest innovations such as Excel Spark lines when generating PDF files.

For those not familiar with the product, the PDF Converter for SharePoint is a lightweight solution that allows end-users to convert common document types to PDF format from within SharePoint using a friendly user interface, workflows or a web service call without the need to install any client side software or Adobe Acrobat. It integrates at a deep level with SharePoint and leverages facilities such as the Audit log, localisation, security and tracing. It runs on WSS 3, MOSS as well as SharePoint 2010 and is available in English, German, Dutch, French, Traditional Chinese and Japanese. For detailed information check out the product page.

New support for the Ribbon in SharePoint 2010

The main changes in version 3.4 are as follows:

792	New - Added support for SharePoint 2010 RTM
845	New - Added Taiwanese translations (Traditional Chinese)
827	Fix - MS-Word Paragraph borders are not rendered correctly when saved as PDF
782	Fix - Excel 2010 has problems converting ODS files
483	Fix - Resources not deployed on farms where 'Timer Account' is not local administrator
524	Fix - STSADM and Timerjob are fighting over access to layouts.sitemap
787	Fix - Resources don't deploy when SharePoint 2010 Timer service account is not local Admin
797	New - Make license manager SP2010 compatible
840	Fix - Convert to PDF is not present on Folder Context Menu in SP2010 & SP2007
841	Fix - PDF Converter loads slowly on very big (100K+ items) Document Libraries
833	Fix - Too much logging during anonymous requests
808	New - Added support for Server and Enterprise Licenses
821	New - Added Sample Java code to Setup Project
822	New - Added Sample .net code to Setup Project
825	New - Added test harness executable to setup and Start Menu

For more information check out the following resources:

As always, feel free to contact us using Twitter, our Blog, regular email or subscribe to our newsletter.

Download your free trial here (6MB). .

Convert Office files to PDF Format from Java using a Web Services based interface

2010-04-20T14:10:00.001+01:00

As we have been receiving an increasing number of requests for Java based sample code for the Muhimbi PDF Converter Services (MDCS), we have decided to lift the relevant chapter from the Developer Guide and publish it in this blog post. A .NET version of this post is available here.

For those not familiar with the product, the MDCS is a server based SDK that allows software developers to convert typical Office files, including MS-Word, Excel, PowerPoint, Visio, Publisher and InfoPath, to PDF format using a robust, scalable but friendly Web Services interface from Java and .NET based solutions.

Even though the MDCS itself must run on a Windows based server, it has been designed to interoperate with non-Windows platforms such as Java. This section describes how to convert documents to PDF format using a Java based environment.

The full version of the sample code discussed in this post, including pre generated proxies, is installed alongside each copy of the MDCS.

The example described below assumes the following:

The JDK has been installed and configured.
The MDCS and all prerequisites have been installed in line with the Administration Guide.
The MDCS is running in the default anonymous mode. This is not an absolute requirement, but it makes initial experimentation much easier.

The first step is to generate proxy classes for the web service by executing the following command:

wsimport http://localhost:41734/Muhimbi.DocumentConverter.WebService/?wsdl
-d src -Xnocompile -p com.muhimbi.ws

Feel free to change the package name and destination directory to something more suitable for your organisation.

Wsimport automatically generates the Java class names. Unfortunately some of the generated names are rather long and ugly so you may want to consider renaming some, particularly the Exception classes, to something friendlier. This, however, means that if you ever run wsimport again you will need to re-apply those changes. For more information have a look at the high level overview of the Object Model exposed by the web service.

Once the proxy classes have been created add the following sample code to your project. Run the code and make sure the path to the document to convert is specified on the command line. (Download Source Code)

package com.muhimbi.app;               
              
import com.muhimbi.ws.*;               
import java.io.*;               
import java.net.URL;               
import java.util.List;               
import javax.xml.bind.JAXBElement;               
import javax.xml.namespace.QName;               
              
public class WsClient {               
              
  private final static String DOCUMENTCONVERTERSERVICE_WSDL_LOCATION =               
        "http://localhost:41734/Muhimbi.DocumentConverter.WebService/?wsdl";               
              
  public static void main(String[] args) {               
    try {               
      if (args.length != 1) {               
        System.out.println("Please specify a single file name on the command line.");  
      } else {               
        // ** Process command line parameters               
        String sourceDocumentPath = args[0];               
        File file = new File(sourceDocumentPath);               
        String fileName = getFileName(file);               
        String fileExt = getFileExtension(file);               
              
        System.out.println("Converting file " + sourceDocumentPath);               
              
        // ** Initialise Web Service               
        DocumentConverterService_Service dcss = new DocumentConverterService_Service(               
            new URL(DOCUMENTCONVERTERSERVICE_WSDL_LOCATION),               
            new QName("http://tempuri.org/", "DocumentConverterService"));               
        DocumentConverterService dcs = dcss.getBasicHttpBindingDocumentConverterService();               
              
        // ** Only call conversion if file extension is supported               
        if (isFileExtensionSupported(fileExt, dcs)) {               
          // ** Read source file from disk               
          byte[] fileContent = readFile(sourceDocumentPath);               
              
          // ** Converting the file               
          OpenOptions openOptions = getOpenOptions(fileName, fileExt);               
          ConversionSettings conversionSettings = getConversionSettings();               
          byte[] convertedFile = dcs.convert(fileContent, openOptions, conversionSettings);               
              
          // ** Writing converted file to file system               
          String destinationDocumentPath = getPDFDocumentPath(file);               
          writeFile(convertedFile, destinationDocumentPath);               
          System.out.println("File converted sucessfully to " + destinationDocumentPath);               
              
        } else {               
          System.out.println("The file extension is not supported.");               
        }               
      }               
              
    } catch (IOException e) {               
      System.out.println(e.getMessage());               
    } catch (DocumentConverterServiceGetConfigurationWebServiceFaultExceptionFaultFaultMessage e) {               
      printException(e.getFaultInfo());               
    } catch (DocumentConverterServiceConvertWebServiceFaultExceptionFaultFaultMessage e) {               
      printException(e.getFaultInfo());               
    }               
  }               
              
  public static OpenOptions getOpenOptions(String fileName, String fileExtension) {               
    ObjectFactory objectFactory = new ObjectFactory();               
    OpenOptions openOptions = new OpenOptions();               
    openOptions.setOriginalFileName(objectFactory.createOpenOptionsOriginalFileName(fileName));               
    openOptions.setFileExtension(objectFactory.createOpenOptionsFileExtension(fileExtension));               
    return openOptions;               
  }               
              
  public static ConversionSettings getConversionSettings() {               
    ConversionSettings conversionSettings = new ConversionSettings();               
    conversionSettings.setQuality(ConversionQuality.OPTIMIZE_FOR_PRINT);               
    conversionSettings.setRange(ConversionRange.ALL_DOCUMENTS);               
    conversionSettings.getFidelity().add("Full");               
    conversionSettings.setFormat(OutputFormat.PDF);               
    return conversionSettings;               
  }               
              
  public static String getFileName(File file) {               
    String fileName = file.getName();               
    return fileName.substring(0, fileName.lastIndexOf('.'));               
  }               
              
  public static String getFileExtension(File file) {               
    String fileName = file.getName();               
    return fileName.substring(fileName.lastIndexOf('.') + 1, fileName.length());               
  }               
              
  public static String getPDFDocumentPath(File file) {               
    String fileName = getFileName(file);               
    String folder = file.getParent();               
    if (folder == null) {               
      folder = new File(file.getAbsolutePath()).getParent();               
    }               
    return folder + File.separatorChar + fileName + '.' + OutputFormat.PDF.value();               
  }               
              
  public static byte[] readFile(String filepath) throws IOException {               
    File file = new File(filepath);               
    InputStream is = new FileInputStream(file);               
    long length = file.length();               
    byte[] bytes = new byte[(int) length];               
              
    int offset = 0;               
    int numRead;               
    while (offset < bytes.length && (numRead = is.read(bytes, offset, bytes.length - offset)) >= 0) {               
      offset += numRead;               
    }               
              
    if (offset < bytes.length) {               
      throw new IOException("Could not completely read file " + file.getName());               
    }               
    is.close();               
    return bytes;               
  }               
              
  public static void writeFile(byte[] fileContent, String filepath) throws IOException {               
    OutputStream os = new FileOutputStream(filepath);               
    os.write(fileContent);               
    os.close();               
  }               
              
  public static boolean isFileExtensionSupported(String extension, DocumentConverterService dcs)               
    throws DocumentConverterServiceGetConfigurationWebServiceFaultExceptionFaultFaultMessage               
    {               
      Configuration configuration = dcs.getConfiguration();               
      final JAXBElement<ArrayOfConverterConfiguration> converters = configuration.getConverters();               
      final ArrayOfConverterConfiguration ofConverterConfiguration = converters.getValue();               
      final List<ConverterConfiguration> cList = ofConverterConfiguration.getConverterConfiguration();               
                
      for (ConverterConfiguration cc : cList) {               
        final List<String> supportedExtension = cc.getSupportedFileExtensions().getValue().getString();               
        if (supportedExtension.contains(extension)) {               
          return true;               
        }               
    }               
              
    return false;               
  }               
              
  public static void printException(WebServiceFaultException serviceFaultException) {               
    System.out.println(serviceFaultException.getExceptionType());               
    JAXBElement<ArrayOfstring> element = serviceFaultException.getExceptionDetails();               
    ArrayOfstring value = element.getValue();               
    for (String msg : value.getString()) {               
      System.out.println(msg);               
    }               
  }               
              
}

Use Server Side Java & .NET to Convert Word, Excel, PowerPoint, Publisher & Visio to PDF

2010-04-19T15:27:00.001+01:00

We are very excited to announce our first product spin-off, the Muhimbi PDF Converter Services (MDCS), a server side solution to convert typical MS-Office files to PDF Format in a robust and scalable manner from any web services capable environment, including Java and .NET.

The MDCS is a spin-off from our popular PDF Converter for SharePoint. Much of the logic is the same, but all the SharePoint specific bells and whistles have been removed and the documentation has been completely rewritten and includes both Java and .NET sample code.

Key features:

Convert popular document types to PDF or XPS format with near perfect fidelity.
Scalable architecture that allows multiple conversions to run in parallel. The service can be scaled up by adding additional CPUs and scaled out by using standard HTTP Load Balancers.
Runs as a Windows Service. No need to install or configure IIS or other web service frameworks.
Convert password protected documents.
Apply security settings to generated PDF files including encryption, password protection and multiple levels of PDF Security options to prevent users from printing documents or copying a document’s content.
Generate regular PDF files or files in PDF/A format.
Generate high resolution PDF Files optimised for printing or normal resolution files optimised for use on screen.
Dynamically refresh a document’s content before generating the PDF. Ideal for merging content from external sources into your PDF file.
Control how to convert hidden / selected content such as PowerPoint Slides and Excel worksheets.

The web services class diagram is displayed below. A blog post describing how to use the Web Service in a .NET environment can be found here.

Powerful Web Services based interface. Click to enlarge

For more information check out the following resources:

As always, feel free to contact us using Twitter, our Blog, regular email or subscribe to our newsletter.

Download your free trial here (4MB).

Adding a dynamic watermark to a PDF file from a SharePoint Workflow

2010-03-24T13:04:00.001Z

We have had a great response to our previous post about watermarking PDF files, however quite a few customers have told us that they want to use a dynamic watermark (e.g. a username, ip address etc) rather than a static one.

Update: Please note that as of version 3.5 the PDF Conversion Service also supports a native watermarking interface.

The solution presented below executes a workflow whenever a PDF file is added to a document library. It then applies security settings to prevent the watermark from being removed and then reads the watermark text from a SharePoint column. The workflow author can specify if the watermark is placed in the foreground or the background as well as the level of transparency. As the code is well documented it is easy to make further changes and customisations, e.g. the PDF file that needs to be watermarked may not be the file the workflow is acting on or the watermarked text may come from a workflow variable rather than a list column.

Create the workflow as follows:

Download and install the Muhimbi Workflow Power Pack for SharePoint.
Download and install the Muhimbi PDF Converter for SharePoint.
Note that you need version 3.1.2.18 or newer, older versions do not allow watermarking.
Download this article’s source code.
We need to be able to access functionality in the Muhimbi.SharePoint.DocumentConverter.PDF and System.Drawing assemblies. Add these references to the relevant Web Application using the Workflow Power Pack Central Administration screens as described in the Administration Guide. Make sure to place each reference on a new line.
Make sure you have the appropriate privileges to create workflows on a site collection.
Create a new column named Watermark in the Shared Documents library. The content of this column will be used as the text for the watermark.
Create a new workflow using SharePoint Designer.
On the Workflow definition screen associate the workflow with the Shared Documents library, tick the box next to ‘Automatically start this workflow when a new item is created’ and proceed to the next screen. Please note that if you tick the ‘auto start on update’ box as well then the PDF file may be watermarked multiple times leading to unexpected results.
We only want to act on files of type PDF. Although we could have put this validation in the code, in this example we use a workflow condition for it so add a Compare Any Data Source condition and:

a. Click on the first value followed by the display data binding (fx) button.
b. Select Current Item as the Source and select File Type in the Field. Click the OK button to continue.
d. Click on the second value and enter pdf. (Use lower case as the compare option is case sensitive).
Click the Actions button and insert the Execute Custom Code action.
Optionally click parameter 1 and enter a relative or absolute destination path. Leave the parameter empty to save the watermarked file on top of the existing PDF file. For details about how paths are handled, see this post and search for the words ‘this url’.

Insert the C# based code embedded in step #3’s download (also listed below) by clicking this code.

/*********************************************************************************************

                          Muhimbi PDF Converter - Dynamic Watermarking

              Copyright 2010, Muhimbi Ltd - www.muhimbi.com - All rights reserved

 The following code shows a simple way of adding a dynamic watermark to existing PDF Files.

 The watermark content is read from a SharePoint column and rendered on the center of the page.

 Error and permission checking as well as other minor features have been omitted for the sake

 of brevity and clarity.

 Ideally PDF Conversion, applying security and watermarking is executed in the same step, see

 http://www.muhimbi.com/blog/2010/01/configure-pdf-security-from-sharepoint.html

 This code requires Muhimbi’s PDF Converter and Workflow Power Pack to be installed.

**********************************************************************************************/

using System.Drawing;

using System.IO;

using Syncfusion.Pdf;

using Syncfusion.Pdf.Parsing;

using Syncfusion.Pdf.Graphics;

using Muhimbi.SharePoint.DocumentConverter.PDF;

using Syncfusion.Pdf.Security;

SPFile spSourceDocument = MyWorkflow.Item.File;

string destinationFileName = spSourceDocument.Name;

string destinationFolderName = MyWorkflow.Parameter1 as string;

// ** Read the text from the Column named 'Watermark', use a column name of your choice.

string watermark = MyWorkflow.Item["Watermark"] as string;

string pdfOwnerPassword = "some!Strong^Password";

// ** z-order and transparency of the watermark

bool watermarkInBackground = true;

float watermarkTransparancy = 0.25f;

// ** Method for creating a simple template, amend as needed

WorkflowFunction<string, PdfTemplate> CreateWatermark = delegate(string[] parameters)

    const float watermarkWidth = 250;

    const float watermarkHeight = 23;

    string watermarkText = parameters[0];

    if(watermarkText==null)

        watermarkText = "no watermark specified";

    // ** Create a new Template

    PdfTemplate template = new PdfTemplate(watermarkWidth, watermarkHeight);

    PdfGraphics tg = template.Graphics;

    // ** Rectangle

    PdfPen pen = new PdfPen(PdfBrushes.Black, 1);

    tg.DrawRectangle(pen, PdfBrushes.White, new RectangleF(0, 0, watermarkWidth,

                                                           watermarkHeight));

    // ** Evaluation message text

    using (Font f = new Font("Arial", 10f, FontStyle.Regular))

        PdfFont font = new PdfTrueTypeFont(f, false);

        PdfStringFormat stringFormat = new PdfStringFormat();

        stringFormat.Alignment = PdfTextAlignment.Center;

        stringFormat.LineAlignment = PdfVerticalAlignment.Middle;

        stringFormat.WordWrap = PdfWordWrapType.WordOnly;

        stringFormat.ClipPath = true;

        tg.DrawString(watermarkText, font, PdfBrushes.Black, new RectangleF(5, 0,

                                watermarkWidth - 10, watermarkHeight), stringFormat);

    return template;

};

// ** Method for applying security settings, amend / uncomment as needed

WorkflowMethod<PdfLoadedDocument> ApplySecurity = delegate(PdfLoadedDocument[] pdfDocuments)

    PdfLoadedDocument pdfDocument = pdfDocuments[0];

    // ** Enable encryption of content

    pdfDocument.Security.KeySize = PdfEncryptionKeySize.Key128Bit;

    // ** Specify the password used for modifying permissions

    pdfDocument.Security.OwnerPassword = pdfOwnerPassword;

    // ** Apply the restrictions, if any. Note that by default nothing is

    // ** allowed and we need to individually enable permissions

    pdfDocument.Security.Permissions = PdfPermissionsFlags.Default;

    // ** Allow Commenting / annotations

    pdfDocument.Security.SetPermissions(PdfPermissionsFlags.EditAnnotations);

    // ** Allow Accessibility

    //pdfDocument.Security.SetPermissions(PdfPermissionsFlags.AccessibilityCopyContent);

    // ** Allow Copy content via clipboard etc.

    //pdfDocument.Security.SetPermissions(PdfPermissionsFlags.CopyContent);

    // ** Allow Assemble / modification of document

    //pdfDocument.Security.SetPermissions(PdfPermissionsFlags.AssembleDocument);

    // ** Allow Form fields to be filled out

    pdfDocument.Security.SetPermissions(PdfPermissionsFlags.FillFields);

    // ** Allow high resolution printing

    pdfDocument.Security.SetPermissions(PdfPermissionsFlags.FullQualityPrint);

    // ** Allow any kind of printing

    pdfDocument.Security.SetPermissions(PdfPermissionsFlags.Print);

};

// ** Load the document from SharePoint

PdfLoadedDocument sourceDocument = new PdfLoadedDocument(spSourceDocument.OpenBinary());

// ** Restrict the rights

ApplySecurity(sourceDocument);

// ** Create the watermark Template

PdfTemplate watermarkTemplate = CreateWatermark(watermark);

// ** Iterate over all pages and apply the watermark

foreach (PdfPageBase page in sourceDocument.Pages)

    // ** Position the watermark at the centre of the page

    float wmWidth = watermarkTemplate.Width;

    float wmHeight = watermarkTemplate.Height;

    float wmLeft = ((page.Size.Width - wmWidth) / 2);

    float wmTop = ((page.Size.Height - wmHeight) / 2);

    PointF wmPosition = new PointF(wmLeft, wmTop);

    // ** Place watermark behind or in front of text?

    if (watermarkInBackground == true)

        PdfTemplate pageTemplate = page.CreateTemplate();

        page.Layers.Clear();

        PdfGraphics g = page.Graphics;

        g.SetTransparency(watermarkTransparancy);

        g.DrawPdfTemplate(watermarkTemplate, wmPosition);

        g.SetTransparency(1f);

        g.DrawPdfTemplate(pageTemplate, PointF.Empty, page.Size);

    else

        PdfGraphics g = page.Graphics;

        g.SetTransparency(watermarkTransparancy);

        g.DrawPdfTemplate(watermarkTemplate, wmPosition);

// ** Construct the path and file to write the watermarked PDF file to.

if (string.IsNullOrEmpty(destinationFolderName) == true)

    destinationFolderName = spSourceDocument.ParentFolder.Url;

SPFolder destinationFolder = Utility.GetSPFolder(destinationFolderName, MyWorkflow.Web);

string destinationFilePath = string.Format("{0}/{1}", destinationFolder.Url,

                                           destinationFileName);

SPWeb destinationWeb = destinationFolder.ParentWeb;

SPFile spDestinationFile = destinationWeb.GetFile(destinationFilePath);

// ** If a document library requires manual checkout and the file is not checked out, then

// ** check the file out before uploading.

if (spDestinationFile.Exists && spDestinationFile.Item.ParentList.ForceCheckout &&

    spDestinationFile.CheckOutStatus == SPFile.SPCheckOutStatus.None)

    spDestinationFile.CheckOut();

// ** Add the file to the site including the meta data

using (MemoryStream watermarkedFile = new MemoryStream())

    sourceDocument.Save(watermarkedFile);

    spDestinationFile = destinationWeb.Files.Add(destinationFilePath, watermarkedFile,

                                                 spSourceDocument.Item.Properties, true);

// ** Check the file back in if this script was responsible for checking it out.

if (spDestinationFile.Item.ParentList.ForceCheckout == true)

    spDestinationFile.CheckIn("Auto check-in after PDF watermarking.");

Click the Actions button, select Log to History List, click this message and enter File watermarked.
Close the Workflow Designer.
Add a new PDF file to your library to trigger the workflow and apply the watermark. Make sure the content for the Watermark field is specified when the file is added as otherwise a generic watermark text will be inserted.

Naturally this is just a simple example. Feel free to play around with the code, change which parameters are passed into the workflow, modify where watermarked files are written to or use a different source for the watermark text. Leave a comment below if you are trying to do anything specific.

Update: If you get the message ‘no watermark specified’ then the workflow may have been triggered before you specified the contents of the Watermark field. For details see SharePoint Designer workflows trigger before properties are set.

Porting a SharePoint 2007 WSPBuilder solution to SharePoint 2010 – Part 4

2010-03-17T11:40:00.003Z

In the final part of our series about porting a SharePoint 2007 based WSPBuilder project to SharePoint 2010 we discuss the changes made to our Installation scripts in order to make it work with both versions of SharePoint.

Please note that this article is based on our experiences with the beta version of SharePoint 2010. Some of the issues we have identified may have been resolved in the final release.

The following posts are part of this series:

Part 1 – Introduction / Problems installing the existing 2007 version on SP2010
Part 2 – Reconfiguring the Visual Studio Solution
Part 3 – Programmatic / visual changes
Part 4 – Updating deployment scripts (This post)

Installation Script

The installation scripts used for deploying the SharePoint part of our solutions are simple Windows CMD scripts. Our customers appear to prefer it this way as it allows them to see what is going on and make necessary amendments to deploy the software as part of a larger deployment script. Unfortunately we cannot use PowerShell as that technology is not available on all systems.

In order to make the same script work on SharePoint 2007 as well as 2010 environments we have had to make the following changes:

Detect which version of SharePoint is installed.
Adjust the STSADM path accordingly.
Adjust the name of the WSP file accordingly as the WSP files for both environments are different.

The resulting installation script is as follows:

@echo off

echo *******************************************************************************

echo Installing Muhimbi PDF Converter for SharePoint.       (c) 2010 www.muhimbi.com

echo *******************************************************************************

echo.

REM ** Detect which version of SharePoint is installed.

SET STSADM="%CommonProgramFiles%\Microsoft Shared\Web Server Extensions\14\bin\STSADM.EXE"

SET SolutionWSP=Muhimbi.PDFConverter.SP2010.wsp

if exist %STSADM% goto endVersionDetection

    SET STSADM="%CommonProgramFiles%\Microsoft Shared\Web Server Extensions\12\bin\STSADM.EXE"

    SET SolutionWSP=Muhimbi.PDFConverter.wsp

    if exist %STSADM% goto endVersionDetection

    echo - SharePoint does not appear to be installed on this server.

    goto endOfScript

:endVersionDetection

echo - Adding solution to Solution Store

%STSADM% -o addsolution -filename %SolutionWSP%

%STSADM% -o execadmsvcjobs

echo - Deploying solution

%STSADM% -o deploysolution -name %SolutionWSP% -immediate -allowgacdeployment -force

%STSADM% -o execadmsvcjobs

echo - Feature is self activating

echo - Deploying Resources

%STSADM% -o copyappbincontent

echo - If you are experiencing problems when accessing the solution then

echo   please read the Administration guide, particularly section 3.5.

echo - Installation finished.

:endOfScript

echo.

pause

Un-Installation Script

The changes required to the un-installation script are similar to the changes for the installation script. As the name of the Timer Service has changed between SharePoint 2007 and 2010 this name has been made dynamic as well.

The resulting script is as follows:

@echo off

echo *******************************************************************************

echo Un-installing Muhimbi PDF Converter for SharePoint.    (c) 2010 www.muhimbi.com

echo *******************************************************************************

echo.

REM ** Detect which version of SharePoint is installed.

set STSADM="%CommonProgramFiles%\Microsoft Shared\Web Server Extensions\14\bin\STSADM.EXE"

set TimerServiceName="SharePoint 2010 Timer"

SET SolutionWSP=Muhimbi.PDFConverter.SP2010.wsp

if exist %STSADM% goto endVersionDetection

    SET SolutionWSP=Muhimbi.PDFConverter.wsp

    set STSADM="%CommonProgramFiles%\Microsoft Shared\Web Server Extensions\12\bin\STSADM.EXE"

        set TimerServiceName="windows sharepoint services timer"

    if exist %STSADM% goto endVersionDetection

    echo - SharePoint does not appear to be installed on this server.

    goto endOfScript

:endVersionDetection

SET SolutionWSP="Muhimbi.PDFConverter.wsp"

echo - Retracting solution.

%STSADM% -o retractsolution -name %SolutionWSP% -immediate

%STSADM% -o execadmsvcjobs

echo - Wait for the solution to be retracted across the farm (Check Central Admin).

pause

echo - Removing solution from Store.

%STSADM% -o deletesolution -name %SolutionWSP%

%STSADM% -o execadmsvcjobs

echo - Restarting timer service in order to release any GAC DLLs.

net stop %TimerServiceName%

net start %TimerServiceName%

echo - Un-installation finished.

:endOfScript

echo.

pause

That’s it. We hope you have enjoyed this series. Please leave feedback if you have any questions.

Porting a SharePoint 2007 WSPBuilder solution to SharePoint 2010 – Part 3

2010-03-15T14:46:00.001Z

In part of 3 of our series about porting a SharePoint 2007 based WSPBuilder project to SharePoint 2010 we discuss the changes made to our code in order to make everything work, and look good, in both versions of SharePoint

Please note that this article is based on our experiences with the beta version of SharePoint 2010. Some of the issues we have identified may have been resolved in the final release.

The following posts are part of this series:

Part 1 – Introduction / Problems installing the existing 2007 version on SP2010
Part 2 – Reconfiguring the Visual Studio Solution
Part 3 – Programmatic / visual changes (This post)
Part 4 – Updating deployment scripts

Fixing Central Administration links

We started of with the easy bit that required no coding, unless you consider writing XML files coding. As the configuration screen for our PDF Converter is located under External Service Connections in SharePoint 2007, we decided to add it to the same location in SharePoint 2010.

We added the Custom Action for SharePoint 2010 to the same elements file that holds the SharePoint 2007 definition. SharePoint will simply ignore locations it has no knowledge about, which is very convenient in this case.

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

  <!-- Settings screen in SP2007 Central Administration Application Management -->

  <CustomAction

    Id="Muhimbi.SharePoint.Administration.....ExternalService.DocumentConverterSettings"

    Title="Muhimbi Document Converter Settings"

    Location="Microsoft.SharePoint.Administration.ApplicationManagement"

    GroupId="ExternalService"

    Sequence="51"

    <UrlAction Url="~site/_admin/Muhimbi.PDFConverter/WebAppDocumentConverterSettings.aspx"/>

  </CustomAction>

  <!-- Settings screen in SP2010 Central Administration Application Management -->

  <CustomAction

    Id="Muhimbi.....GeneralApplicationSettings.ExternalServiceConnections.DocumentConverterSettings"

    Title="Muhimbi Document Converter Settings"

    Description="Configure the Muhimbi Document Converter settings."

    Location="Microsoft.SharePoint.Administration.GeneralApplicationSettings"

    GroupId="ExternalServiceConnections"

    Sequence="51"

    <UrlAction

        Url="/_admin/Muhimbi.PDFConverter/WebAppDocumentConverterSettings.aspx" />

  </CustomAction>

Updated elements.xml file. Note that some IDs have been truncated for readability

Note that we had to change both the GroupID and Location for SharePoint 2010. At the time of writing a full list of Groups and Locations has not yet been published by Microsoft, but Arjen Bloemsma has created his own preliminary list. If the location you want to target is not found in Arjen’s list then you can follow the procedure set out below:

Open Central Administration and navigate to the section you want to place your link in.
Write down the name of an ASPX file that is already in that section.
Search in C:\Program Files\Common Files\Microsoft Shared\Web Server Extensions\14\TEMPLATE\FEATURES for all files containing that file name.
Open the file and copy the GroupID and Location.

Muhimbi Document Converter Settings in External Service Connections

Adding support for the Ribbon

With the links in Central Administration fixed we moved on to the SharePoint 2010 Ribbon. As we didn’t want to introduce too much change to our back end, we decided to only allow a single document to be selected for conversion at a time. Fortunately the SharePoint team had just provided an example on their blog about disabling a Ribbon button when more than 1 item is selected. Unfortunately their code didn’t work, but it gave us a good starting point.

The Ribbon is quite well documented. For details see:

Once we had the Ribbon changes up and running on SharePoint 2010 we noticed that SharePoint 2007 was no longer able to accept the WSP file. As a result we decided to create a shadow SPHive_2010 folder and modify our build scripts to create two separate WSP Files. For more details see Part 2 – Reconfiguring the Visual Studio Solution.

<CustomAction

 Id="Muhimbi.SharePoint.DocumentConverter.PDF.Ribbon.Documents.Copies.Controls.PDFConversion.Action"

 Location="CommandUI.Ribbon"

 RegistrationType="ContentType"

 RegistrationId="0x0101"

  <CommandUIExtension>

    <CommandUIDefinitions>

      <CommandUIDefinition

        Location="Ribbon.Documents.Copies.Controls._children">

        <Button Id="Muhimbi.SharePoint.DocumentConverter.PDF.Ribbon.Documents.Copies.Controls.

                    PDFConversion.Button"

                Command="Muhimbi.SharePoint.DocumentConverter.PDF.Ribbon.Documents.Copies.Controls.

                         PDFConversion.Button.Command"

                Image16by16="/_layouts/images/Muhimbi.PDFConverter/pdf16.gif"

                Image32by32="/_layouts/images/Muhimbi.PDFConverter/pdf32.gif"

                LabelText="$Resources:ecb_title;"

                Sequence="11"

                TemplateAlias="o1" />

      </CommandUIDefinition>

    </CommandUIDefinitions>

    <CommandUIHandlers>

      <CommandUIHandler

        Command="Muhimbi.SharePoint.DocumentConverter.PDF.Ribbon.Documents.Copies.Controls.

                 PDFConversion.Button.Command"

        CommandAction="javascript:window.location='{SiteUrl}/_layouts/Muhimbi.PDFConverter/

                       Convert.aspx?ListId={ListId}&amp;ItemId={ItemId}&amp;Source=' +

                       window.location"

        EnabledScript="javascript:function singleEnable()

          var items = SP.ListOperation.Selection.getSelectedItems();

          var ci = CountDictionary(items);

          return (ci == 1);

        singleEnable();" />

    </CommandUIHandlers>

  </CommandUIExtension>

</CustomAction>

Custom Action for the PDF Conversion button and script to only allow a single selection

Note that we have wrapped some lines in the code listed above to make things more readable. When copying this code, please make sure everything between double quotes, with the exception of the EnabledScript attribute, is placed on a single line.

Look at our new button in the Ribbon, isn’t it shiny?

Fixing visual problems

As you may remember from Part 1 – Introduction / Problems installing the existing 2007 version on SP2010, the formatting of certain page elements don’t look quite right in SharePoint 2010. The main problems were related to the vertical spacing of check boxes and additional vertical space being added between elements.

After some investigation we decided that the easiest way to solve these rending problems was to add a little bit of conditional code that checks the version number of SharePoint and depending on the version output some additional CSS styles.

<!-- Additional SP2010 Styles. Disabled by default -->

<style id="sp2010AdditionalStyles" runat="server" Disabled="true">

.FixSP2010CheckBox {position:relative; top:2px}

#ctl00_PlaceHolderMain_convertersSection .ms-authoringcontrols IMG { display:none}

.FixSP2010Button {position:relative; top:-2px}

</style>

... Irrelevant code removed

<asp:Button id="btnTestServer" Text="Test" OnClick="btnTestServer_OnClick"

class="ms-ButtonHeightWidth FixSP2010Button" style="width:80px" runat="server"/>

... Irrelevant code removed

<wssawc:InputFormCheckBox ID="chkAllowWordProcessing" CssClass="FixSP2010CheckBox"

               LabelText="Word Processing (e.g. MS-Word, RTF, TXT)" runat="server"/>

<wssawc:InputFormCheckBox ID="chkAllowSpreadsheets" runat="server" CssClass="FixSP2010CheckBox"

               LabelText="Spreadsheets (e.g. Excel, CSV)"/>

... etc

Changes to the ASPX Application page (Relevant fragments only)

/// <summary>

/// Resolve the differences between SharePoint 2007 and 2010

/// </summary>

private void FixSharePointDifferences()

    int spVersion = SPFarm.Local.BuildVersion.Major;

    if (spVersion == 12)

        // ** SharePoint 2007

        sp2010AdditionalStyles.Disabled = true;

    else

        // ** SharePoint 2010

        sp2010AdditionalStyles.Disabled = false;

Changes to the Code Behind file. Invoke this method from the page’s OnLoad

With these changes in place the screens suddenly look a lot better in SharePoint 2010. As the style changes are not active in SharePoint 2007 everything continues to work fine in that environment as well.

SharePoint 2010 look and feel before and after fixing visual problems

Miscellaneous changes

In addition to some minor code changes, the addition of the DynamicMasterPageFile attribute is worth mentioning as well. By replacing the MasterPageFile attribute - in Application Pages hosted inside a site collection - with DynamicMasterPageFile, the Quick Access menu is magically added to the left of the page. The absence of this menu in previous SharePoint versions has always been a pet peeve to me.

Note that this new attribute is incompatible with SharePoint 2007. Therefore a copy of the ASPX file with the MasterPageFile attribute replaced with DynamicMasterPageFile will need to be placed in the shadow SPHive_2010 folder. We tried setting this value manually (via reflection) in the page’s PreInit event, but that resulted in the SharePoint 2010 page being rendered in the SharePoint 2007 look and feel.

<%@ Page Language="C#" DynamicMasterPageFile="~masterurl/default.master" 
         Inherits="Muhimbi.SharePoint.DocumentConverter.PDF.Convert" %>

Continue to Part 4 – Updating deployment scripts.