PsAccelerator: Word

Showing posts with label Word. Show all posts

Monday, June 20, 2011

Update an open XML word document in F#

I have created a small function in F# to update the content of a word document.

//reference to the package 
#r "WindowsBase"
//reference to the Xml and Linq 
#r "System.Xml"
#r "System.Xml.Linq"

open System
open System.IO
open System.IO.Packaging
open System.Xml
open System.Xml.Linq

//helper to create XName with a namespace
let xname str =
XName.Get(str, "http://schemas.openxmlformats.org/wordprocessingml/2006/main")

// the main function 
// changeDoc copies a word .docx document and updates the content by changing the xml that represents the content
let changeDoc oldPath newPath (updateDocument:XDocument -> XDocument) =
//update the package part
let updatePart (part:PackagePart) =
using (part.GetStream(FileMode.Open, FileAccess.Read)) (fun stream -> 
let xDocumentOut = stream |> XDocument.Load |> updateDocument
xDocumentOut.Save(part.GetStream(FileMode.Create, FileAccess.Write))
)

File.Copy(oldPath, newPath, true)
using (Package.Open(newPath, FileMode.Open, FileAccess.ReadWrite)) (fun package ->
let uri = new Uri("/word/document.xml", UriKind.Relative )

uri |> package.GetPart|> updatePart
)

// test function to update the document
// adds "_test" to every text  in the document.
let updateText (xDoc:XDocument) =
"t" |> xname  |> xDoc.Descendants |> Seq.iter (fun x -> x.Value <- x.Value + "_test")
xDoc

//test
changeDoc @"D:\Tmp\test.docx" @"D:\Tmp\test_copy.docx" updateText;;

Before "D:\Tmp\test.docx":

After "D:\Tmp\test_copy.docx":

Tuesday, June 7, 2011

Create Open XML Word document in F# (update)

This time I will create a word document (open xml) in F# without using the Open XML SDK and using XML libraries. Things have been intentionally kept simple.

I start by modelling a simple word document:

There are Two types of paragraphs: normal and bold ones:

 //reference to the package 
#r "WindowsBase"
 
open System
open System.IO
open System.IO.Packaging
 
type Paragraph =
    | Normal of string
    | Bold of string
 

And a document is a list of paragraphs:

 type Document =
    | Paragraphs of Paragraph list
 

This is the test:

 //test
let list = [Normal("test1"); Normal("test2"); Bold("test3"); Normal("test4")]
let doc = Paragraphs(list)
 

Next we have the to create an xml version of document:

//helpers

// http://weblogs.sqlteam.com/mladenp/archive/2008/10/21/Different-ways-how-to-escape-an-XML-string-in-C.aspx

let encodedXml (text: string) =

    text.Replace("&", "&amp;").Replace("<", "&lt;").Replace(">", "&gt;").Replace("\"", "&quot;").Replace("'", "&apos;")

let xml1 = "<node>it's my \"node\" & i like it<node>"

let encode = encodedXml xml1

let addString acc item = acc + "\r\t" + item

let createParagraphNormal text =

    "<w:p>

      <w:r>

        <w:t>" + encodedXml text + 

        "</w:t>

      </w:r>

    </w:p>"

let createParagraphBold text =

    "<w:p>

      <w:r>

        <w:rPr>

         <w:b />

        </w:rPr>

        <w:t>" + encodedXml text + 

        "</w:t>

      </w:r>

    </w:p>"

let createParagraph = function

    | Normal(text) -> createParagraphNormal text

    | Bold (text) -> createParagraphBold text

let createParagraphs = function

    | Paragraphs(list) -> list|> List.map createParagraph |> List.reduce addString

//test

let p = createParagraphs doc

let createDocument doc =

    let startDocument = @"<?xml version=""1.0"" encoding=""utf-8""?>

                    <w:document xmlns:w=""http://schemas.openxmlformats.org/wordprocessingml/2006/main"">

                      <w:body>"

    let endDocument = "  </w:body>

                        </w:document>"

    let content = createParagraphs doc

    startDocument + content + endDocument

Then we have to create a package, add the document and save it to disk:

//add the document to package and save

let createFile doc (fileName:string) =

    using (Package.Open(fileName, FileMode.Create, FileAccess.ReadWrite))(fun package ->

        let uri = new Uri("/word/document.xml", UriKind.Relative )

        let partDocumentXML = 

            package.CreatePart(

                                uri,

                                "application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml" )

        using(new StreamWriter(partDocumentXML.GetStream(FileMode.Create, FileAccess.Write)))(fun stream ->

            doc |> createDocument |> stream.Write

        )

        package.CreateRelationship(

                                    uri,

                                    TargetMode.Internal,

                                    "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument",

                                    "rId1") |> ignore

    )

//test

let fileName = @"D:\Tmp\test.docx"

createFile doc fileName;;

This is the result:

I have created a map from twitter to my document model

type UserStatus = 

    { UserName : string; 

      ProfileImage : string; 

      Status : string; 

      StatusDate : DateTime }

let mapUserStatus (us:UserStatus) =

    let date = "Date: " + us.StatusDate.ToShortDateString()  + " time: " + us.StatusDate.ToLongTimeString()

    [Normal(date); Bold(us.UserName); Normal(us.Status); Normal("")]

let addUserStatus acc item = item @ acc

let result = xml|> parseTweetXml |> List.map mapUserStatus|> List.reduce addUserStatus

(the details of the twitter part can be found at: http://blogs.msdn.com/b/dsyme/archive/2010/01/10/async-and-parallel-design-patterns-in-f-reporting-progress-with-events-plus-twitter-sample.aspx)

This results in the following document:

Remark: I had to Google “Weiner” to understand the jokes.

Tuesday, May 24, 2011

Create Open XML Word document in F#

I needed a word document. I created it with the Open XML SDK and F# and posted the snippet at fssnip.net.

1: //reference to the Open Office SDK

2: #r @"C:\Program Files (x86)\Open XML SDK\V2.0\lib\DocumentFormat.OpenXml.dll"

3: //reference to the package

4: #r "WindowsBase"

6: open DocumentFormat.OpenXml

7: open DocumentFormat.OpenXml.Wordprocessing

8: open DocumentFormat.OpenXml.Packaging

10: let testString = "This is a test"

11: let printXml text =

12: printfn "xml: %s" text

13:

14: let createBody (text:string) =

15: let text = new Text(text)

16: let run = new Run()

17: run.AppendChild(text) |> ignore

18: let para = new Paragraph()

19: para.AppendChild(run)|> ignore

20: let body = new Body()

21: body.AppendChild(para)|> ignore

22: body

23:

24: printXml (createBody testString).InnerXml

25:

26: let createDocument (text:string) =

27: let body = createBody text

28: let doc = new Document()

29: doc.AppendChild(body) |> ignore

30: doc

31:

32: printXml (createDocument testString).InnerXml

33:

34: let createWordprocessingDocument (filepath:string) text=

35: using (WordprocessingDocument.Create(filepath, WordprocessingDocumentType.Document)) (fun doc ->

36: let mainPart = doc.AddMainDocumentPart();

37: mainPart.Document <- createDocument text

38: )

39:

40: let result3 = createWordprocessingDocument @"D:\Tmp\test1.docx" testString

It is a direct transformation of the C# code from the help file of the Open XML SDK:

public static void CreateWordprocessingDocument(string filepath)

    // Create a document by supplying the filepath.

    using (WordprocessingDocument wordDocument =

        WordprocessingDocument.Create(filepath, WordprocessingDocumentType.Document))

        // Add a main document part.

        MainDocumentPart mainPart = wordDocument.AddMainDocumentPart();

        // Create the document structure and add some text.

        mainPart.Document = new Document();

        Body body = mainPart.Document.AppendChild(new Body());

        Paragraph para = body.AppendChild(new Paragraph());

        Run run = para.AppendChild(new Run());

        run.AppendChild(new Text("Create text in body - CreateWordprocessingDocument"));