SharePoint Designer Zip/Compress Workflow Action Deployed in a Sandboxed Solution

Whew, that was a long title – But I think you’ll find this very useful. Some notes on deploying a custom workflow action that you can use inside of SharePoint designer, which will Zip attachments to list items and deposit the compressed file in a document library – and it is all deployed in a sandboxed solution, so you can use it on hosted SharePoint Foundation instances. In this case, I even generate PDF files with the data from the list items, and include them in the compressed file. Great for archival or offsite storage.

First of all, this MSDN article about general workflow actions and sandboxed solutions will help you immensely with the basics:

http://msdn.microsoft.com/en-us/library/gg615449.aspx

Next you’ll want to grab a copy of:

SharpZipLib (an open source compression library)
SharpPDF (if you want to generate PDF’s too)

You’ll want to get the source to each, as we’ll upgrade them to .net 4.0, and build them as signed assemblies.

Make yourself a SharePoint solution in Visual Studio per the MSDN article above, and add two (or one if you are leaving out the PDF bits) existing projects using the source of the libraries (SharpZip, SharpPDF).

You’ll need to let the upgrade wizard upgrade them to .net 4.
Check the project settings on them and make sure they are targeting the .net 4 framework (AnyCPU)
For SharpPDF you’ll need to open the AssemblyInfo.cs file and add a line to the bottom

[assembly: AllowPartiallyTrustedCallers()]

1

[assembly: AllowPartiallyTrustedCallers()]

.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, “Courier New”, courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }

In my case, I’m always looking at a single list, so my workflow action only accepts a ListItemID. You’ll probably want to make that more generic by adding a few more parameters to your Action. Again, these custom actions are described in plenty of detail in the MSDN article referenced above.

       <span class="kwrd">public</span> <span class="kwrd">static</span> Hashtable Package(SPUserCodeWorkflowContext context, <span class="kwrd">string</span> ItemID)
        {
            Hashtable result = <span class="kwrd">new</span> Hashtable();

            <span class="kwrd">try</span>
            {
                result[<span class="str">&quot;Result&quot;</span>] = PackageListItem(closingId, context.CurrentWebUrl);
            }
            <span class="kwrd">catch</span> (Exception e)
            {
                result[<span class="str">&quot;Result&quot;</span>] = <span class="str">&quot;ERROR&quot;</span> + e.ToString();
            }

            <span class="kwrd">return</span> result;
        }

public static Hashtable Package(SPUserCodeWorkflowContext context, string ItemID)

{

Hashtable result = new Hashtable();

try

{

result["Result"] = PackageListItem(closingId, context.CurrentWebUrl);

}

catch (Exception e)

{

result["Result"] = "ERROR" + e.ToString();

}

return result;

}

Where the PackageListItem method looks like this:

        <span class="kwrd">public</span> <span class="kwrd">static</span> <span class="kwrd">string</span> PackageListItem(<span class="kwrd">string</span> ItemID, <span class="kwrd">string</span> webUrl)
        {
            SortedList&lt;<span class="kwrd">string</span>, <span class="kwrd">byte</span>[]&gt; files = <span class="kwrd">new</span> SortedList&lt;<span class="kwrd">string</span>,<span class="kwrd">byte</span>[]&gt;();
            
            <span class="kwrd">using</span> (SPSite site = <span class="kwrd">new</span> SPSite(webUrl))
            {
                <span class="kwrd">using</span> (SPWeb web = site.OpenWeb())
                {
                    <span class="rem">//Find the list item</span>
                    SPListItem item = web.Lists[<span class="str">&quot;List&quot;</span>].GetItemById(<span class="kwrd">int</span>.Parse(ItemID));

                    <span class="rem">//Create a PDF of the list item data and add it to the </span>
                    <span class="rem">//  compressed files collection</span>
                    files.Add(<span class="str">&quot;ListData.pdf&quot;</span>, CreateDocument(item, <span class="str">&quot;Title&quot;</span>));

                    <span class="rem">//Loop through all list item attachments</span>
                    <span class="rem">//  and add them to the compressed file collection</span>
                    <span class="kwrd">foreach</span> (<span class="kwrd">string</span> attachment <span class="kwrd">in</span> item.Attachments)
                    {
                        SPFile attFile = web.GetFile(item.Attachments.UrlPrefix + attachment);
                        files.Add(attachment, attFile.OpenBinary());
                    }
                    
                    <span class="rem">//Zip everything up and finish!</span>
                    <span class="kwrd">byte</span>[] package = CreateZip(files);

                    files = <span class="kwrd">null</span>;

                    web.AllowUnsafeUpdates = <span class="kwrd">true</span>;

                    <span class="rem">//Add the zipped package to a doc lib</span>
                    SPFile file = web.Folders[<span class="str">&quot;Archive&quot;</span>].Files.Add(
                        <span class="kwrd">string</span>.Format(<span class="str">&quot;({0})_{1}.zip&quot;</span>, 
                        ItemID, 
                        DateTime.Now.ToString(<span class="str">&quot;yyyy'-'MM'-'dd HH''mm''ss&quot;</span>)), 
                        package);

                    web.Update();

                    file.Update();

                    web.AllowUnsafeUpdates = <span class="kwrd">false</span>;

                    package = <span class="kwrd">null</span>;

                    <span class="rem">//return the List Item ID of the generated file to the workflow</span>
                    <span class="kwrd">return</span> file.ListItemAllFields[<span class="str">&quot;ID&quot;</span>].ToString();

                }
            }
        }

public static string PackageListItem(string ItemID, string webUrl)

{

SortedList<string, byte[]> files = new SortedList<string,byte[]>();

using (SPSite site = new SPSite(webUrl))

{

using (SPWeb web = site.OpenWeb())

{

//Find the list item

SPListItem item = web.Lists["List"].GetItemById(int.Parse(ItemID));

//Create a PDF of the list item data and add it to the

// compressed files collection

files.Add("ListData.pdf", CreateDocument(item, "Title"));

//Loop through all list item attachments

// and add them to the compressed file collection

foreach (string attachment in item.Attachments)

{

SPFile attFile = web.GetFile(item.Attachments.UrlPrefix + attachment);

files.Add(attachment, attFile.OpenBinary());

}

//Zip everything up and finish!

byte[] package = CreateZip(files);

files = null;

web.AllowUnsafeUpdates = true;

//Add the zipped package to a doc lib

SPFile file = web.Folders["Archive"].Files.Add(

string.Format("({0})_{1}.zip",

ItemID,

DateTime.Now.ToString("yyyy'-'MM'-'dd HH''mm''ss")),

package);

web.Update();

file.Update();

web.AllowUnsafeUpdates = false;

package = null;

//return the List Item ID of the generated file to the workflow

return file.ListItemAllFields["ID"].ToString();

}

And create document, if you are interested in generating PDF’s, looks like this. I do some hackery to leave out boring version and guid fields from the list data – feel free to do something more intelligent:

 <span class="kwrd">public</span> <span class="kwrd">static</span> <span class="kwrd">byte</span>[] CreateDocument(SPListItem item, <span class="kwrd">string</span> type)
        {
            pdfDocument pdf = <span class="kwrd">new</span> pdfDocument(type, <span class="str">&quot;Some Text&quot;</span>);
            pdfPage page = pdf.addPage();

            page.addText(item[<span class="str">&quot;Title&quot;</span>].ToString(), 20, 730, pdf.getFontReference(predefinedFont.csHelvetica), 12);

            pdfTable table = <span class="kwrd">new</span> pdfTable(pdf, 1, pdfColor.Black);
            table.borderSize = 1;
            table.borderColor = pdfColor.Black;
            table.coordX = 50;
            table.coordY = 690;


            table.tableHeader.addColumn(150);
            table.tableHeader.addColumn(300);

            <span class="kwrd">foreach</span> (SPField f <span class="kwrd">in</span> item.Fields)
            {
                <span class="kwrd">if</span> (f.Type != SPFieldType.Guid &amp;&amp; !f.Title.ToLower().Contains(<span class="str">&quot;version&quot;</span>) &amp;&amp; !f.Title.Contains(<span class="str">&quot;Title&quot;</span>))
                {
                    <span class="kwrd">try</span>
                    {
                        pdfTableRow row = table.createRow();
                        row[0].addText(f.Title);
                        row[1].addText(item[f.InternalName].ToString());
                        table.addRow(row);
                    }
                    <span class="kwrd">catch</span> { }
                }
            }
            
            page.addTable(table);

            MemoryStream ms = <span class="kwrd">new</span> MemoryStream();
            pdf.createPDF(ms);

            <span class="kwrd">return</span> ms.ToArray();
        }

public static byte[] CreateDocument(SPListItem item, string type)

{

pdfDocument pdf = new pdfDocument(type, "Some Text");

pdfPage page = pdf.addPage();

page.addText(item["Title"].ToString(), 20, 730, pdf.getFontReference(predefinedFont.csHelvetica), 12);

pdfTable table = new pdfTable(pdf, 1, pdfColor.Black);

table.borderSize = 1;

table.borderColor = pdfColor.Black;

table.coordX = 50;

table.coordY = 690;

table.tableHeader.addColumn(150);

table.tableHeader.addColumn(300);

foreach (SPField f in item.Fields)

{

if (f.Type != SPFieldType.Guid && !f.Title.ToLower().Contains("version") && !f.Title.Contains("Title"))

{

try

{

pdfTableRow row = table.createRow();

row[0].addText(f.Title);

row[1].addText(item[f.InternalName].ToString());

table.addRow(row);

}

catch { }

}

page.addTable(table);

MemoryStream ms = new MemoryStream();

pdf.createPDF(ms);

return ms.ToArray();

}

The CreateZip method called in package is also very simple:

 <span class="kwrd">public</span> <span class="kwrd">static</span> <span class="kwrd">byte</span>[] CreateZip(SortedList&lt;<span class="kwrd">string</span>, <span class="kwrd">byte</span>[]&gt; files)
        {

            MemoryStream ms = <span class="kwrd">new</span> MemoryStream();

            <span class="kwrd">using</span> (ZipOutputStream s = <span class="kwrd">new</span> ZipOutputStream(ms))
            {

                s.SetLevel(5); <span class="rem">// 0 - store only to 9 - means best compression</span>

                <span class="kwrd">foreach</span> (<span class="kwrd">string</span> file <span class="kwrd">in</span> files.Keys)
                {

                    <span class="rem">// Using GetFileName makes the result compatible with XP</span>
                    <span class="rem">// as the resulting path is not absolute.</span>
                    ZipEntry entry = <span class="kwrd">new</span> ZipEntry(file);

                    <span class="rem">// Could also use the last write time or similar for the file.</span>
                    entry.DateTime = DateTime.Now;
                    s.PutNextEntry(entry);

                    s.Write(files[file], 0, files[file].Length);                    
                }

            }

            <span class="kwrd">return</span> ms.ToArray();

        }

public static byte[] CreateZip(SortedList<string, byte[]> files)

{

MemoryStream ms = new MemoryStream();

using (ZipOutputStream s = new ZipOutputStream(ms))

{

s.SetLevel(5); // 0 - store only to 9 - means best compression

foreach (string file in files.Keys)

{

// Using GetFileName makes the result compatible with XP

// as the resulting path is not absolute.

ZipEntry entry = new ZipEntry(file);

// Could also use the last write time or similar for the file.

entry.DateTime = DateTime.Now;

s.PutNextEntry(entry);

s.Write(files[file], 0, files[file].Length);

}

return ms.ToArray();

}

This is relatively resource intensive of course, and will use some of your sandboxed resources. It hasn’t been a problem for me, but your mileage may vary.

Leave a Reply Cancel reply