The OpenXML file format used by Microsoft Office 2007 enables programmatic document manipulation without automating Word, so that Word does not need to be installed alongside your code, which is great for server applications. In this post, I’ll show you how to use OpenXML to implement bi-directional data binding between a Word document and XML data. This new feature in Word 2007 delivers the best data/view separation we’ve seen to date in Microsoft Office. And (for a LINQ junkie such as myself, anyway) the best part is that it works so nicely with LINQ to XML.

We’ll begin by creating a document with content controls. Then we’ll write a small amount of code to embed an XML file into the document and bind the content controls to various elements in the XML.

Before starting, you need to download the OpenXML SDK 2.0. Once the SDK is installed, you’ll have the assemblies you need to programmatically manipulate Office documents using the OpenXML API. You can download the SDK from here: http://www.microsoft.com/downloads/details.aspx?FamilyId=C6E744E5-36E9-45F5-8D8C-331DF206E0D0&displaylang=en

Create the Document

We’ll create a simple document with three content controls that will be bound to the following XML data:

<Customer>
  <Name>John Doe</Name>
  <Expiration>2/1/2010</Expiration>
  <AmountDue>$129.50</AmountDue>
</Customer>

Start a new document in Word 2007, and type the word Dear followed by a space. We now want to inject our first content control for the customer name. You can add content controls to your document from the Developer tab on the ribbon, but since that tab is hidden by default, you’ll need to show it first. Click the Office button and choose Word Options. Then check the “Show Developer tab in the Ribbon” checkbox and click OK.

With the cursor still positioned after the text “Dear “, click in the Developer tab to insert a new Text content control:

We’ll be assigning tag names to identify content controls for data binding in our code. To view the tag names in Word as we setup the content controls, click the Design Mode button in the Developer tab:

With the content control still selected, click Properties:

Set the Tag of the content control to Customer/Name, which is an XPath expression that refers to the <Name> element nested inside the <Customer> element of our XML data.

Click OK to close the dialog box. Notice how Word displays the tag name in the content control in Design Mode:

Continue adding text to the document, and insert two more content controls in a similar fashion for the expiration date and amount due fields. Use the same Text content control for the amount due field like we used for the customer name field, but use a Date Picker content control for the expiration date field:

After setting the tag names of the additional content controls to the appropriate XPath expressions (Customer/Expiration and Customer/AmountDue), your document should look something like this:

Turn off Design Mode to hide the tag names from the content controls:

Save the document as CustomerReminder.docx. We have already established a separation of variable data and fixed document text, and could easily setup document protection at this point to allow manual data entry only for content controls. That’s cool all by itself, but we’re going to take this to the next level and implement automatic data binding between these content controls and a separate XML file. Although Word doesn’t care what values you assign to content control tags, we will now write code to find all tagged content controls, and treat those tags as XPath expressions that point to various XML elements in our XML data.

If you’re not already aware, all Office 2007 documents (including Word docx files) are actually compressed zip files (“packages”) that hold a collection of related XML “parts.” You can see this easily by simply appending .zip to the document filename and then opening it from Windows Explorer:

After examining the contents of the document package, rename the filename extension back to “.docx.”

Write the Code

Start Visual Studio and create a new Windows Forms project. Now set references to the two assemblies you’ll need for OpenXML programming: DocumentFormat.OpenXml and WindowsBase (these can be found on the .NET tab of the Add Reference dialog box). The first assembly exposes the OpenXML object model for document manipulation, and the second assembly provides the support for embedding and extracting parts to and from the document package:

Drop a button onto the form named btnInit and supply code for its Click event handler. You’ll also need a few additional using statements for importing some namespaces. The complete code listing below shows the required using statements and the btnInit_Click event handler.

using System;
using System.IO;
using System.Linq;
using System.Windows.Forms;
using System.Xml.Linq;

using DocumentFormat.OpenXml.Packaging;
using DocumentFormat.OpenXml.Wordprocessing;

namespace OpenXmlWordDataBinding
{
  public partial class Form1 : Form
  {
    public Form1()
    {
      InitializeComponent();
    }

    private void btnInit_Click(object sender, EventArgs e)
    {
      var xml =
        new XElement("Customer",
          new XElement("Name", "John Doe"),
          new XElement("Expiration", "2/1/2010"),
          new XElement("AmountDue", "$129.50"));

      var docxFile = @"..\..\CustomerReminder.docx";

      using (var wpd = WordprocessingDocument.Open(docxFile, true))
      {
        var mainPart = wpd.MainDocumentPart;
        var xmlPart = mainPart.AddNewPart<CustomXmlPart>();
        using (Stream partStream = xmlPart.GetStream(FileMode.Create, FileAccess.Write))
        {
          using (StreamWriter outputStream = new StreamWriter(partStream))
          {
            outputStream.Write(xml);
          }
        }

        var taggedContentControls =
          from sdt in mainPart.Document.Descendants<SdtRun>()
          let sdtPr = sdt.GetFirstChild<SdtProperties>()
          let tag = (sdtPr == null ? null : sdtPr.GetFirstChild<Tag>())
          where tag != null
          select new
          {
            SdtProps = sdtPr,
            TagName = tag.GetAttribute("val", "http://schemas.openxmlformats.org/wordprocessingml/2006/main").Value
          };

        foreach (var taggedContentControl in taggedContentControls)
        {
          var binding = new DataBinding();
          binding.XPath = taggedContentControl.TagName;
          taggedContentControl.SdtProps.Append(binding);
        }

        mainPart.Document.Save();
      }
    }
  }
}

Let’s analyze this code piece by piece. First, we construct the XML data as a graph of XML objects using LINQ to XML functional construction:

var xml =
  new XElement("Customer",
    new XElement("Name", "John Doe"),
    new XElement("Expiration", "2/1/2010"),
    new XElement("AmountDue", "$129.50"));

Next, we invoke WordprocessingDocument.Open to open the Word document for write access using the OpenXML SDK. We do this inside of a using block to ensure proper disposal of unmanaged resources in the event that unhandled exception occurs inside of the block. The boolean true value specified for the second parameter means that we’re opening the document for write access:

var docxFile = @"..\..\CustomerReminder.docx";
using (var wpd = WordprocessingDocument.Open(docxFile, true))

Our code needs to do two things to the document at this point: add a new XML part containing the data to be bound, and assign the appropriate bindings to the content controls. Realize that this is code that will only execute once; subsequently, we’ll only be extracting/embedding the XML part from/to the document package using normal zip compression methods.

Add a New XML Part

With the document open and accessible to our code via the wpd variable, we invoke the AddNewPart<CustomXmlPart> method on wpd.MainDocumentPart to retrieve a new XML part in xmlPart. The new XML part exposes a GetStream method that enables us to stream content into and out of it. We take the generic Stream returned by GetStream and wrap a StreamWriter around it. The XML content can then be sent into the new XML part by writing to the StreamWriter. Again, we use nested using blocks on the stream objects to ensure proper cleanup if an exception occurs:

var mainPart = wpd.MainDocumentPart;
var xmlPart = mainPart.AddNewPart<CustomXmlPart>();
using (Stream partStream = xmlPart.GetStream(FileMode.Create, FileAccess.Write))
{
  using (StreamWriter outputStream = new StreamWriter(partStream))
  {
    outputStream.Write(xml);
  }
}

Now that the XML data is embedded as an XML part inside of the document’s .docx package, it’s available for data binding to content controls. The next and last thing we need to do is to programmatically find the tagged content controls inside the document and assign XML data bindings using the XPath expressions we defined in the content control tags.

Add the Data Bindings

Learning how to program Word with OpenXML is all about exploring the special XML markup language used by Word (a dialect known as WordprocessingML) and discovering the element and attribute names used to represent the document. You can view the document’s markup by examining the word/document.xml part inside of the .docx package. It can take quite a bit of detective work as you undergo the exploration and discovery process, but once you’re armed with the information you need, it’s very simple and straightforward to write a LINQ to XML query to get at what you need to in the document.

For example, here is how the customer name content control is expressed in WordprocessingML:

<w:sdt>
     <w:sdtPr>
           <w:tag w:val="Customer/Name"/>
           <w:id w:val="852281"/>
           <w:placeholder>
                <w:docPart w:val="DefaultPlaceholder_22675703"/>
           </w:placeholder>
           <w:showingPlcHdr/>
           <w:text/>
     </w:sdtPr>
     <w:sdtContent>
           <w:r w:rsidRPr="004E1B99">
                <w:rPr>
                      <w:rStyle w:val="PlaceholderText"/>
                </w:rPr>
                <w:t>Click here to enter text.</w:t>
           </w:r>
     </w:sdtContent>
</w:sdt>

An analysis of this XML shows how Word stores content controls inside a document. Specifically, Word creates a <w:sdt> element (structured document tag) and nests a <w:sdtPr> element (structured document tag properties) inside of it. And nested beneath that, Word stores the content control’s tag name in the w:val attribute of a <w:Tag> element. These element names can be referred to programmatically using the OpenXML API type names SdtRun, SdtProperties, and Tag, respectively. Thus, the following LINQ to XML query retrieves all tagged content controls in our document:

var taggedContentControls =
  from sdt in mainPart.Document.Descendants<SdtRun>()
  let sdtPr = sdt.GetFirstChild<SdtProperties>()
  let tag = (sdtPr == null ? null : sdtPr.GetFirstChild<Tag>())
  where tag != null
  select new
  {
     SdtProps = sdtPr,
     TagName = tag.GetAttribute("val", "http://schemas.openxmlformats.org/wordprocessingml/2006/main").Value
  };

In this query, the from clause uses the Descendants<SdtRun> method to retrieve all the <w:sdt> elements in the document. For each one, the first let clause uses the GetFirstChild<SdtProperties> method to retrieve the nested <w:sdtPr> element beneath it. The second let clause then performs a similar operation to retrieve the <w:tag> element nested beneath that. Since you cannot assume that every <w:sdt> element will always have a nested <w:sdtPr> element, the second let clause tests sdtPr for null before trying to invoke GetFirstChild<Tag> on it. The where clause ultimately filters our all content controls that have not been tagged.

The select clause constructs an anonymous type that returns two properties for each tagged content control. The first is the <w:sdtPr> which will be needed to reference the location at which we’ll inject the XML binding element. The second is the tag name extracted from the <w:tag> element’s <w:val> attribute (the full OpenXML namespace needs to be specified for w to retrieve the attribute value), which supplies the XPath expression for the binding. The LINQ query returns the results in a sequence that we then iterate to set the bindings:

foreach (var taggedContentControl in taggedContentControls)
{
  var binding = new DataBinding();
  binding.XPath = taggedContentControl.TagName;
  taggedContentControl.SdtProps.Append(binding);
}

mainPart.Document.Save();

For each tagged content control, we create a DataBinding object, set its XPath property to the tag name which is known provide an XPath expression referencing the desired XML data, and add the binding as a new element inside of the <w:sdtPr> element. Finally, invoking the Save method saves the modified document back to disk. If you examine the WordprocessingML now, you’ll see that our code added a <w:dataBinding> element with a w:xpath attribute to the <w:sdtPr> element in each content control. For example, the customer name content control now has the following element in its <w:sdtPr> section:

<w:dataBinding w:xpath="Customer/Name" />

Now let’s examine the docx package again. Add the .zip extension to the document filename and crack it open. Notice the new customXML folder that wasn’t there before. This is where all custom XML parts added to the document get stored.

Double-click the customXML folder to reveal the item.xml file contained inside of it:

Now double-click item.xml to view it in IE:

Look familiar? That’s the XML our code injected into the document as a custom XML part!

Now close the zip, rename the file back as .docx, and open it in Word:

All the content placeholders have now been filled in with data from our XML file Does it get better than this? You bet! This thing works bi-directional. So go ahead and change John Doe to Sue Taylor:

Now save the document, and rename it as .zip once again. This time, extract the item.xml file instead of opening it in IE, so that you can edit it in Notepad:

Beautiful. Word pushed the data from the modified content controls in the document back out to the XML file. Let’s now edit the XML; for example, we’ll change the expiration date:

Save the XML file, push it back into the zip package, rename the zip package back to .docx, and re-open it in Word one last time:

Now that’s what I call data/view separation! With XML data binding in Word, your application can easily view and change data elements without ever digging into the document text.

Of course, this only scratches the surface of what’s possible with OpenXML. It’s also worth mentioning that the same thing can be achieved using VSTO (Visual Studio Tools for Office) and the Word object model, but we’ll leave that for a future post. Until then, happy coding!

Esse post é para aqueles que insistem em agir como a “turma do deixa disso”, sempre entrando em discussões com expressões do tipo “não entendo todo esse ódio à Microsoft” ou “o melhor software é aquele que mais gostamos”. Isso é pra mostrar que nenhuma grande empresa, principalmente se for monopolista no seu ramo de atividades, é boazinha ou está preocupada com seus clientes, aos quais chama de “consumidores”. O objetivo de todas elas, sem excessão, é o lucro a qualquer preço e ilude-se quem defende essas empresas apaixonadamente, sem conhecimento dos fatos.

Este também é um post para os que lutam por uma sociedade mais justa e mais humana, que tenha por objetivo o desenvolvimento humano e a valorização das pessoas, em detrimento do poder econômico.

É revoltante ver o que essa empresa faz para conseguir o que deseja. A delegação brasileira na BRM (Ballot Resolution Meeting) da ISO foi ultrajada e as demais delegações de 37 países foram feitas de palhaços para que a proposta da Microsoft de um “padrão” de documentos fechado (binário), conhecido como OpenXML fosse aprovada como uma proposta de norma (ISO/IEC DIS 29500, Information Technology – Office Open XML file formats).

A ISO/IEC DIS 29500:2008 é uma proposta de norma internacional apresentada pela Microsoft para concorrer com a ISO/IEC DIS 26000:2006 que trata do mesmo assunto, porém já aprovada e em vigor, e que instituiu o padrão ODF (Open File Document) como norma internacional de formatação de documentos como textos, planilhas de cálculo e apresentações. Segundo a Microsoft, essa proposta tem a intenção de ser implementada em múltiplas aplicações e plataformas. De acordo com a Microsoft, um dos seus objetivos é assegurar a preservação de documentos a longo prazo, criados nas últimas duas décadas, utilizando programas que seriam incompatíveis com a norma ISO/IEC 26000:2006, devido aos avanços da tecnologia da informação.

Até aí, nada de mais. Entretanto, se a proposta é tão inocente e idônea, por que a Microsoft utilizou de meios não ortodoxos (para não dizer inescrupulosos) para fazer valer sua proposta? Por que o padrão não pode ser e não foi avaliado pelos especialistas? Por que a direção da ISO foi manipulada a corroborar com essas práticas desonestas?

Recentemente, recebi um comentário de uma pessoa que se identificou apenas como Rodrigo, em outro post, onde comentava sobre o Microsoft SOL e seus perigos para os pequenos e médios empresários. Neste comentário, Rodrigo disse que “não é verdade que a Microsoft não segue padrões”. Bom, lendo os depoimentos de Jomar Silva, um dos integrantes da delegação brasileira na reunião. Jomar Silva tem sido, nos últimos 3 ou 4 anos, um denunciador das práticas desonestas da Microsoft nos bastidores dos organismos internacionais de normatização e é uma autoridade no assunto.

Jomar Silva é engenheiro eletrônico, pós graduado em gestão de projetos e desenvolvimento de sistemas e Diretor Geral da ODF Alliance Chapter Brasil. Atua no mercado de TI desde 1996, com ênfase no desenvolvimento de software em projetos de Pesquisa e Desenvolvimento para empresas do setor de Telecomunicações e Tecnologia da Informação. Atua ainda como “advisor” em padrões abertos junto a indústria de software. É coordenador do Grupo e Trabalho na ABNT que tratou da adoção do ODF como norma brasileira e membro do OASIS ODF TC (comitê internacional que desenvolve o padrão ODF). Isso lhe confere a autoridade para falar com conhecimento de causa.

Vejam toda a história aqui:

http://www.itweb.com.br/blogs/blog.asp?cod=86
http://homembit.com/2009/10/openxml-o-que-eu-ainda-nao-contei-sobre-o-brm.html

Open Document Format - Formato Aberto de Documentos

Enquanto nas listas de discussão, fóruns e comunidades das redes de relacionamento ainda se discute apaixonadamente questões como “quem é melhor, Linux ou Windows”, nos grandes organismos internacionais verdadeiras batalhas para definir o que eu, você e o resto dos pobres mortais do planeta usaremos ou deixaremos de usar em nossos computadores num futuro muito próximo. Nestes locais pode-se encontrar gente muito jovem e trabalhadora como Jomar Silva, Alexandre Oliva, César Taurion, Rubens Queiroz entre muitos outros, mas também encontra-se gente muito velhaca e mal-intencionada. Acompanhando os posts sobre a guerra de bastidores entre os padrões ODF e OpenXML no blog do Jomar Silva, começamos a entender por que as coisas são do jeito que são, e também começamos a entender por que as pessoas são manipuladas a tal ponto, que defendem cegamente uma corja de sacanas, cujo único objetivo é manter seus lucros e de seus patrões o maior tempo possível no ponto mais alto possível.

Só para dar um exemplo, vou transcrever aqui dois posts do Jomar Silva sobre a guerra do ODF x OpenXML e espero que quem tiver o interesse de ler, divulgue e esclareça para as pessoas comuns, o quanto elas são manipuladas e usadas como massa de manobra o tempo todo, mesmo que não saibam.

O primeiro texto pode ser encontrado aqui:  http://homembit.com/2009/07/a-area-cinzenta-do-odf.html

O segundo texto pode ser encontrado aqui: http://homembit.com/2009/10/openxml-quem-enganou-quem.html

É de deixar qualquer cidadão com um mínimo de consciência revoltado até o tutano do osso.

Texto 1:

A área cinzenta do ODF

July 29th, 2009

Não, o título acima não se refere a uma parte qualquer da especificação, mas ao “ecossistema” que está formado em torno do ODF nos dias de hoje. Há dois anos atrás, quando o assunto era ODF, existiam apenas três tipos de pessoas no mundo:

1 – As que não conheciam o ODF.

2 – As que eram favoráveis ao ODF.

3 – As que eram contrárias ao ODF.

Era muito fácil conhecer cada um dos tipos, e vivíamos numa época conturbada, mas de ações claras e transparentes. Sabíamos quem era quem.

Hoje em dia, as três categorias acima estão praticamente reduzidas a duas:

1 – As que não conhecem o ODF.

2 – As que são favoráveis ao ODF.

A terceira categoria morreu ? … Mais ou menos.

Com o crescimento na adoção internacional do padrão ODF, está se tornando cada vez mais politicamente incorreto ser contra o padrão e por isso, todas aquelas pessoas que tanto fizeram para atrapalhar a adoção, divulgação e desenvolvimento do padrão, hoje se apresentam como “parceiros do ODF” ou “apoiadores do ODF”.

Na verdade, são lobo em pele de cordeiro, trabalhando sorrateiramente para cumprir a mesma agenda (agora oculta), só que do lado de dentro, sem levantar muitas suspeitas dos mais novos e ingênuos na área.

Com isso, tenho sido obrigado a ver estes caras participando de listas de discussão sobre ODF, quer sejam elas de usuários ou desenvolvedores de aplicações, desenvolvendo aplicações de validação e suporte ao ODF e pasmem, até participando (ou tentando participar) do ODF TC.

Nas listas de discussões, o que mais me irrita é a quantidade de vezes que eles utilizam os mesmos argumentos já ultrapassados, copiando e colando uma quantidade gigantesca de texto inútil de uma lista para outra. O pior é que isso toma um tempo enorme das pessoas que realmente trabalham pelo ODF, pois a quantidade de FUD que esse pessoal espalha é assustadora. São a indústria da desinformação.

Para ser honesto, existe uma pessoa em particular dentro deste grupo que se estivesse aqui no Brasil, a comunidade já tinha dado um jeito nele: seria banido. Esse cara é tão chato, mas tão chato que chega a repetir os mesmos argumentos estúpidos e infundados há mais de três anos e ainda tem muita gente que acredita que ele está falando coisa com coisa… sempre o mesmo “copiar e colar”, lista após lista.

Se vocês quiserem um exemplo do tipo de coisa que essa turma é capaz, deem uma olhada na entrada do ODF na Wikipedia (em inglês). Há pouco tempo atrás, era uma importante fonte de informação para o padrão, além de ter a lista mais atualizada que eu conhecia das aplicações que o suportavam. Durante algum tempo, eu ajudei a manter o verbete e coloquei lá todas as informações iniciais sobre adoções de ODF no mundo todo, e perdi alguns dias para coletar, organizar e formatar toda a informação.

Agora, a entrada está completamente detonada.

O primeiro ataque removeu toda a lista de aplicações e a resumiu a uma ridícula lista de seis suítes de escritório, estranhamente incluindo o Microsoft Office (versão antigas via plug-in do Codeplex e versão nova via SP2). Na definição da norma, diziam que o ODF era parecido com o OpenXML. Na lista de adoções que eu tanto trabalhei para montar, deram um jeito de enfiar OpenXML em uma meia dúzia de países, nem que fosse com absurdos como “no documento o OpenXML é citado”… quem será que teria interesse em uma coisas dessas ?

Durante alguns dias, eu até tentei entrar lá e arrumar os estragos que estavam fazendo mas na boa, não tenho mais idade para brincar de gato e rato com delinquente… Se querem a Wikipedia bagunçada, que a tenham, para que fique claro que o jogo deles é sujo mesmo !!! (e o mesmo vale para a entrada sobre a ODF Alliance, que sofre do mesmo problema).

Me dá pena ver agora na Wikipedia a mensagem de que “aparentemente existe um conflito de interesses” com as contribuições ao artigo… não somos todos favoráveis ao ODF ???

É isso que eles querem… confundir, iludir, atrapalhar, retardar… ajudar a dar errado !!! E que isso sirva de lição e de prova para todos aqueles que acham que já está tudo resolvido !!!

Quando me preparava para escrever este post, elaborei a lista completa com os nomes, endereços de e-mail, blogs, sites e em alguns casos empresas de cada um dos “operários da área cinzenta” que já consegui identificar. Com a ajuda de alguns amigos de confiança do mundo todo, preparei ainda uma coletânea de informações que comprovam o passado questionável e não tão distante dessas pessoas.

Como eu acredito que uma boa conversa é sempre primordial antes de uma atitude mais enérgica, resolvi escrever este post para lhes dar um sincero aviso:

“Eu sei quem vocês são, onde vocês estão, com quem se relacionam, de onde vieram e o que vocês estão tentando fazer.

Não me forcem a divulgar tudo isso aqui neste blog, pois a capacidade de cruzamento de informações que teremos a partir daí pode lhes desmascarar de uma vez por todas… e desmascarar ainda quem está por trás de tudo isso.

Respeitem o ODF e quem trabalha honestamente para seu desenvolvimento e divulgação.

Não testem a minha paciência. Com vocês ela é inexistente !

Parem de brincar com coisa séria, e saiam logo desta zona cinzenta (podem voltar para a oposição… eu não me importo com vocês).”

Antes que alguém fique “tendo ideias”, saiba que estas informações que tenho estão salvaguardadas com amigos fieis em diversos países do mundo.

Texto 2:

OpenXML: Quem enganou quem ?

October 14th, 2009

Comecei hoje a desgastante tarefa de ler as correções e emendas ao OpenXML que serão votadas na ISO nos próximos dois meses, e me com isso acabei me lembrando de uma pergunta crucial ainda sem resposta sobre o OpenXML: Quem enganou quem ?Há mais de dois meses foi divulgado o processo que a Microsoft perdeu sobre violação de patentes no OpenXML (o caso i4i). Há quase dois meses, foi publicado um excelente artigo no Groklaw sobre o tema, mas até agora eu não vi nenhuma explicação por parte dos envolvidos, então resolvi escrever este post para explicar com detalhes o que aconteceu, na esperança de que os envolvidos tenham um pingo de decência, caráter e dignidade para responder.

Acho que esta é uma excelente oportunidade para lembrar aos responsáveis pela ISO/IEC, que tudo o que vou relatar ocorreu em um mundo G-8, em que os países que apelaram contra o OpenXML não faziam “parte do grupo”. Hoje vivemos no mundo do G-20 e este é um excelente momento para os senhores demonstrarem que possuem a capacidade readequar suas instituições á nova realidade Internacional. Há um ano, vocês optaram por simplesmente ignoraram os apelos feitos por países em desenvolvimento.

Vamos lembrar da cronologia dos fatos:

Em Março de 2007, a empresa i4i apresenta uma queixa contra a Microsoft sobre violação de patente no OpenXML aos tribunais americanos. Nesta mesma época, o ECMA já estava iniciando seu explicatório dentro do SC34, tentando justificar que o Fast Track (6 meses de prazo) era adequado para a avaliação do OpenXML (mais de 6 mil páginas de especificação). Esta fase do processo ficou conhecida como a fase dos contraditórios.

O tempo passou, o Fast Track foi aceito e o litígio “i4i vs Microsoft” caminhou na justiça. A votação do OpenXML aconteceu e como já era esperado, a especificação foi REJEITADA por ampla maioria no JTC1, e a decisão se amparava em mais de 3 mil problemas técnicos identificados.

O BRM (Ballot Resolution Meeting) foi então convocado, e confesso que até hoje eu não entendo qual era a intenção de quem decidiu convocar esta reunião: Discutir mais de 3 mil problemas técnicos em 5 dias é humanamente impossível (e qualquer cidadão de bem, com sanidade mental e o mínimo de respeito e vergonha na cara percebe isso).

Foi definido também o coordenador do BRM, Alex Brown (que aliás teve papel crucial no resultado final do OpenXML, mas isso é assunto para outro post, pois ainda não revelei tudo o que vi em Genebra), e ele publica em seu blog um FAQ sobre as regras do BRM. Este FAQ circulou ainda como documento oficial da ISO e pode ser lido aqui.

Olhem o que está escrito neste documento:

4.1 Problemas relacionados com Direitos de Propriedade Intelectual serão discutidos no BRM ?

Não. Problemas referentes a Direitos de Propriedade intelectual neste processo são de domínio exclusivo do ITTF. Estes problemas foram previamente delegados por TODOS os membros da ISO e do IEC (NBs) aos CEOs da ISO e do IEC e estes por sua vez, examinaram-os e não encontraram problemas. NBs buscando se certificar disso, devem procurar outros caminhos que não o BRM.

Em outras palavras, os CEOs da ISO e do IEC (autoridades máximas das duas entidades) já haviam avaliado as questões de propriedade intelectual sobre o OpenXML e não encontraram nada, e por isso nenhum comitê no mundo todo precisava se preocupar com a questão… Me lembro de ter questionado esta informação algumas vezes, e a resposta foi sempre a mesma: “Garoto, você está duvidando dos CEOs da ISO e do IEC ?”… e o processo da i4i… como fica ?

Para “não duvidar dos CEOs da ISO e do IEC”, a única explicação que tenho para este fato é a seguinte:

“Houve uma conspiração entre ECMA e Microsoft para omitirem da ISO/IEC o processo da i4i, pois se este processo fosse de conhecimento da ISO/IEC e dos NBs, não tenho dúvidas que o Fast Track do OpenXML seria, no mínimo, suspenso.”

É impossível acreditar que a Microsoft, que possui os advogados mais caros do mundo, não sabia do processo que sofria (há mais de um ano na época do BRM).

Grande parte dos delegados do ECMA que conheci são funcionários da Microsoft ou parceiros de negócio da empresa. Este pessoal pode ser tudo, menos “desinformados” e por isso, não consigo acreditar que o ECMA não sabia do processo.

Por isso, troco a pergunta feita no Groklaw há quase dois meses por uma mais direta: Quem enganou quem ?

Que todos os NBs do mundo foram enganados, que os países viram seus nomes usados de forma inescrupulosa e que todos os delegados técnicos sérios e competentes foram feitos de idiota, já sabemos.

Espero realmente que as partes citadas se manifestem e respondam a toda a sociedade. Não vivemos mais num mundo onde absurdos como este podem ser aceitos, e não vou parar enquanto não encontrar uma resposta (e sei que não estou sozinho nessa busca).

Gostaria ainda de saber da ISO/IEC o que eles têm a dizer sobre tudo isso. Eles sabiam ou não do processo da i4i ?

Mais uma vez, faço um apelo aos CEOs da ISO e do IEC: O G-20 é uma realidade, e nunca é tarde para corrigir uma injustiça !

An Excel workbook can get “hidden” when you embed it within a PowerPoint.

In Office 2007, its possible to embed an Excel worksheet within a PowerPoint slide. You can do this from within PowerPoint by navigating to the ‘Insert’ tab in the Ribbon and then clicking ‘Object’ in the Text grouping.  The dialog box that appears will allow you to create one of several predefined New objects in your slide, or you can Browse to insert an existing object from a file.  From here we can select an Excel .xlsx we’ve created, and the worksheet will appear within our slide.

This can be very cool and useful if we have some analysis we’d like to present.  Also, whenever we select the inserted worksheet within the slide, it will automatically open in Excel so we can continue to tweak on it using Excel’s functionality.

So embed an Excel document in a PowerPoint (from an existing file). But don’t touch or select or tweak the embedding in the slide, just save the presentation .pptx somewhere. Change the .pptx extension to .zip, unzip the document, and you’ll find the embedded Excel .xlsx under /ppt/embeddings.  Yep, there’s a complete Excel .xlsx package within your PowerPoint .pptx.  Now open the .xlsx directly in Excel by double-clicking it; the Excel application will launch, but NOTHING IS VISIBLE! EVEN THOUGH THE SPREADSHEET IS THERE! EXCEL WILL APPEAR AS IF NO WORKBOOKS ARE OPENED!!!

You have to navigate to ‘View’ on the Ribbon and click ‘Unhide’ to see the document.

What Happened?

If you unzip the .xlsx and examine workbook.xml, you’ll find:

/workbook/bookViews/workbookView/@visibility = “hidden” .

This attribute is set for the embedded document, even though it wasn’t set in the original prior to embedding.

But guess what, if you would’ve tweaked the embedding by selecting it or resizing it in the slide prior to saving the .pptx, this attribute wouldn’t be set. You can open the .xlsx and the workbook IS VISIBLE.  This seems to be an odd quirk of PowerPoint’s default behavior that I stumbled upon while embedding documents programmatically.

I can understand why a behavior like this might go unnoticed if it’s expected the embedded document will only ever be opened within PowerPoint again. In PowerPoint the embedded .xlsx opens and is always visible within the context of the slides.

Embed Shmembed.

The thing is, I’m saving these documents to MarkLogic Server, where I automatically unzip all Office 2007 documents so I can search and reuse the XML, document parts, and original source .pptx, .xlsx, .docx, etc.  in the creation of new Office and other documents.  In MarkLogic, one of the things I’m doing for an app is making embedded Office docs available as independent documents within search results.  It’s freedom baby, yeah! And while we’re seeing this behavior with embedding, we now know that its possible to hide any workbook using that simple attribute.

So if we want our users to be able to view the Excel documents they are selecting for use,  a simple solution is to just remove the @visible and rezip the .xlsx in MarkLogic, either in the saved .xlsx, or when opening the embedded doc from the rezipping of its extracted parts, or both.  Remove that attribute and we’re all good for visibility.

Or,  if you’re feeling particularly ornery,  I guess you could add the attribute to all your organization’s Excel workbooks and watch your users go mad?  Maybe there’s a use-case for that, I don’t know.

But I thought this was interesting so I’d share. Maybe this will help someone who’s tweaking on this random behavior or with AddOLEObject as well.  You can have a .xlsx on your filesystem.  You can unzip and see the workbook and worksheet parts.  You can double-click the .xlsx and it will open in Excel, but nothing is visible, even though the worksheet information *IS* saved in the .xlsx package and available in the Excel application.  It turns out the document is actually open, but hidden.  You just have to ‘Unhide’ it.

Microsoft Office 2007, Open Office, and Adobe’s InDesign CS4 all have something in common.  These applications all save their documents as .zip archives of XML files.  As an example, take any .docx, .odt, or .idml file and change the file extension to .zip. Extract the contents and within you’ll find multiple interrelated XML documents.  There are probably other document formats that follow this model as well, but these are the 3 I see questions for on a regular basis. When working with documents of this type, the first thing many people want to do is work with the XML within the zip packages.  Today’s post will demonstrate tools provided by MarkLogic Server for working with these document types, as well as some methods for managing and using the extracted pieces.

To play along at home, install MarkLogic Server, and setup CQ.  The following examples work with the default Documents database and default Docs HTTP Server.  I’ll be using Word 2007 documents, as that’s kinda my thing, but you can use the same code, tools, and methods with the other file formats as well. Just replace the .docx in the samples below with a .odt or .idml file, etc., and everything will just auto-magically work. Ultimately they’re all just zip files of XML and associated resources.  Let’s do this!

The Office OpenXML Extract pipeline

It doesn’t get any easier than this.  If you’re working with Office 2007 documents, you can quickly configure the Server to automatically unzip these files when you save them to your database.  The XML within will be saved in a directory named for the original file, maintaining the naming and directory structure they had within the .zip.  To make this happen, we just need to install content processing and attach the Office OpenXML Extract pipeline.

Install Content Processing

In the Admin UI, navigate to:

Databases -> Documents -> Content Processing

We see a message informing us that Content Processing is not installed. That’s ok.  Click the ‘Install’ tab.

Next we’re presented with an option to ‘enable conversion’.  If you’re running the Community Edition, leave this as false.  Click ‘install’.

Finally, we’re presented with the message ‘Content Processing will be installed for the database test without conversion.’ Click ‘ok’.

Note: There are conversion utilities available that require a separate license.  If you are running a version of the Server other than Community, feel free to install these utilities by setting the enable conversion option to true.  For those on the Community Edition, installing content processing allows us to build our own conversion utilities, as well as take advantage of other available pipelines that don’t require the separate license. w00t!

Now that we’ve installed Content Processing, we just need to attach the Office OpenXML Extract pipeline.

Attach a Content Processing Pipeline

In the Admin UI, navigate to:

Databases -> Documents -> Content Processing -> Domains -> Default Documents -> Pipelines

Make sure that the pipelines ‘Status Change Handling’ and ‘Office OpenXML Extract’ are checked.  Then click ‘ok’.

You’ll now see those pipelines are attached.

Let’s take advantage our freshly configured pipeline. Open CQ and evaluate the following to insert a document.  I’m inserting C:\foo.docx.  The default domain for CPF is the root directory “/”, so remember to prefix the name of your file with “/” in the uri option so the document will be processed.

     xquery version "1.0-ml";
     xdmp:document-load("C:\foo.docx",
                          <options xmlns="xdmp:document-load">
                            <uri>/foo.docx</uri>
                          </options>)

To validate the pipeline ran for the document, evaluate the following in CQ:

     xquery version "1.0-ml";
     xdmp:document-properties("/foo.docx"),
     xdmp:document-properties("/foo_docx_parts/word/document.xml")

Notice in the results returned that A) there are CPF properties on the .docx informing us the XML has been extracted, and B) we are looking at the properties for an extracted Part.  The document.xml is in a sibling directory of the original foo.docx named /foo_docx_parts/.  We now have the original zip package and all its extracted pieces available to us in the Server.  With Content Processing installed and our pipeline configured, anytime we save an Office document to the Server in the future they will be automatically unzipped and their parts will be saved similarly for us in a _parts directory.

Note: The .docx and the parts directory are linked.  Delete the .docx, and the related _parts folder and its extracted pieces will be deleted as well.

So,  What are pipelines?  What’s Content Processing? What was all that configuration we did?

CPF in a Nutshell ( the Content Processing Framework )

MarkLogic Server includes a framework for processing content that we refer to lovingly as CPF.  CPF stands for the Content Processing Framework.  The gist is this: a document has a lifecycle that starts with creation and advances as users/applications update and modify the document.  CPF provides a way to take action on documents based on where they are in their lifecyle.

A pipeline is an XML document that describes a set of content processing steps. It defines the steps that occur during the processing of documents and defines actions that occur at each step.  These actions can be found in supporting XQuery functions and modules. CPF was built for you to create your own content processing applications, with your own content processing code, and following your own logical and business processes.

If you’d like to know more, you can check out the  Content Processing Framework guide, I’ve also provided a quick intro here as well.

Note: the quick intro linked here was written for MarkLogic Server 3.2. For 4.*.* some minor updates are required.  I’ll revisit and update that post in the future, but if you’re interested, the guide should provide enough info to help you modify the example successfully.

But what if we’re not working with Office 2007 documents?  Or we don’t want to use CPF?  Can we still unzip these documents, extract the individual XML files and insert them into our MarkLogic Database?  Yes.

xdmp:zip utilities

When working with .zip files, you’ll want to take a look at the functions xdmp:zip-create(), xdmp:zip-get(), and xdmp:zip-manifest().

I have a Word document, sampleManuscript.docx, that I’ve saved in the directory C:\test.  I can take a look at the names of the files inside the .docx by evaluating the following in CQ:

     xquery version "1.0-ml";
     xdmp:zip-manifest(xdmp:document-get("C:\test\sampleManuscript.docx"))

MarkLogic provides utilities for working with files on the filesystem, but let’s load our document into the Server.

Note: For the following examples, we want to insure CPF does not process our documents for us. So navigate to pipelines, as we did in our configuration steps above.  Uncheck the Office OpenXML Extract pipeline, and click ‘ok’.  This will detach the pipeline so it will not action the example document below on load.

     xquery version "1.0-ml";
     xdmp:document-load("C:\test\sampleManuscript.docx",
                          <options xmlns="xdmp:document-load">
                             <uri>/myManuscript/sampleManuscript.docx</uri>
                          </options>)

The above returns the empty sequence. You can validate that your document inserted properly by clicking ‘explore’ in CQ.  Or by evaluating the following:

     xquery version "1.0-ml";
     xdmp:document-properties("/myManuscript/sampleManuscript.docx")

At a minimum, you’ll see a last-modified metadata timestamp for the document.  If you’ve enabled content processing for the database as we did above, you will see other cpf:* properties.  Assuming no pipelines are attached, the .docx will be in cpf:state initial and no action has been taken to extract its XML parts.

If we want to access a file within the .docx, assuming we know the name of the piece we want  in the .zip,  we can get it using xdmp:zip-get().  The following returns the XML for the document.xml file located within our .docx package.

     xquery version "1.0-ml";
     xdmp:zip-get(fn:doc("/myManuscript/sampleManuscript.docx"),"word/document.xml")

Instead of having to know the names of individual pieces within a .zip package and/or having to extract individual files each time we want to access a piece of XML, let’s just unzip and extract the pieces from our.docx and insert them into a directory, similar to how CPF did for us.

     xquery version "1.0-ml";
     declare namespace zip="xdmp:zip";

     let $doc := "/myManuscript/sampleManuscript.docx"
     let $directory-uri := "/myManuscript/sampleManuscript_docx_parts/"
     let $zipfile := fn:doc($doc)
     let $manifest := xdmp:zip-manifest($zipfile)
     for $part-name in $manifest/zip:part
         let $options := if ($part-name = "/_rels/.rels") then
                             <options xmlns="xdmp:zip-get">
                               <format>xml</format>
                             </options>
                        else
                            <options xmlns="xdmp:zip-get"/>
         let $part := xdmp:zip-get($zipfile, $part-name, $options)
         let $part-uri := fn:concat($directory-uri, $part-name)
         return xdmp:document-insert($part-uri, $part)

We just loop through the manifest, extract the pieces, and insert into a directory. Here we’re explicitly telling the server to treat .rels as XML. With a little modification and refinement, we can easily take the above and make it into a re-usable module. We could even use this as a starting point for creating our own CPF pipeline action.

Zip it!

Now that we’ve extracted XML documents from zip files and saved them to the Server, lets zip ‘em back up.

When we extracted the pieces for sampleManuscript.docx above, we saved them to a directory named   /sampleManuscript_docx_parts/ and we specified this as a subdirectory of the folder /myManuscript/.

When we insert a document to MarkLogic, we specify the name of the file we are saving with a uri parameter (xs:string).  If this string has “/”s in it, the strings in between the slashes will be treated as directories. So “/” marks the path for our content’s location on the Server.  By default, MarkLogic is configured for automatic directory creation. This is done as many people like using directories to manage their content, and it can be very helpful when loading documents using webDAV.  It’s also very helpful for managing unzipped XML packages, as we want to retain the original structure of the document, so when we zip the pieces back up the document will open successfully it in its respective application.

We saved our extracted documents pieces to directories, but we don’t know what pieces were inserted, or what subdirectories were created.  If we enable the uri lexicon for our database, we can evaluate a query using cts:uris that will provide us the uris for all the extracted pieces.  We can then use this to create a manifest and zip the pieces back up.

Validate Directory Creation is Automatic

In Admin UI, navigate to:

Databases -> Documents

Scroll down until you see the property ‘directory creation‘.  The dropdown selection is set to ‘automatic‘.

For more info on directories, refer to the Admin’s Guide, and Application Developer’s Guide.

Enable URI Lexicons

Scroll up, and a few properties up from ‘directory creation’ you’ll find ‘uri lexicon‘.  Set the enabled option to ‘true’ and click ‘ok’.

Now head back to CQ, and evaluate the following:

     xquery version "1.0-ml";
     let $directory := "/myManuscript/sampleManuscript_docx_parts/"
     return cts:uris("","document",cts:directory-query($directory,"infinity"))

The results are a list of all the XML documents we extracted from sampleManuscript.docx.  We can zip them back up and save locally by evaluating the following:

     xquery version "1.0-ml";
     let $directory := "/myManuscript/sampleManuscript_docx_parts/"
     let $uris := cts:uris("","document",cts:directory-query($directory,"infinity"))

     let $parts := (for $i in $uris let $x := fn:doc($i) return $x)

     let $manifest := <parts xmlns="xdmp:zip">
                      {
                       for $i in $uris
                       let $file := fn:substring-after($i,$directory)
                       let $part :=  <part>{$file}</part>
                       return $part
                      }
                      </parts>

     let $pkg := xdmp:zip-create($manifest, ($parts))
     return xdmp:save("C:\test.docx",$pkg)

Double-click on the saved file to open it in Word.  I’ve named it test.docx to demonstrate we can name it anything we want too. More likely we would’ve used the document’s original name, sampleManuscript.docx.

Most of the time though, we’ll want users to be able to dynamically generate their documents on the fly.  Place the following code in a module named opendocx.xqy.  Place it under the /Docs directory for the Server, which is found in the directory where MarkLogic is installed. On Windows the default is C:\Program Files\MarkLogic\Docs.

     xquery version "1.0-ml";
     let $directory := "/myManuscript/sampleManuscript_docx_parts/"
     let $uris := cts:uris("","document",cts:directory-query($directory,"infinity"))

     let $parts := (for $i in $uris let $x := fn:doc($i) return $x)

     let $manifest := <parts xmlns="xdmp:zip">
                      {
                       for $i in $uris
                       let $file := fn:substring-after($i,$directory)
                       let $part :=  <part>{$file}</part>
                       return $part
                      }
                      </parts>

     let $filename := "test.docx"
     let $pkg := xdmp:zip-create($manifest, ($parts))

     let $disposition := concat("attachment; filename=""",$filename,"""")
     let $x := xdmp:add-response-header("Content-Disposition", $disposition)
     let $x:= xdmp:set-response-content-type("application/vnd.openxmlformats-officedocument.wordprocessingml.document")
     return $pkg

In a browser, navigate to the url http://localhost:8000/opendocx.xqy.

Assuming Office 2007 is installed on your machine, the document opens right up into its respective application.

We can just open the .docx as well. Save the following under /Docs as opendocx2.xqy.  Update the url in your browser, and the file will again open from the Server into Word.

     xquery version "1.0-ml";
     let $docname := "/myManuscript/sampleManuscript.docx"
     let $pkg := fn:doc($docname)
     let $filename := "test.docx"
     let $disposition := concat("attachment; filename=""",$filename,"""")
     let $x := xdmp:add-response-header("Content-Disposition", $disposition)
     let $x:= xdmp:set-response-content-type("application/vnd.openxmlformats-officedocument.wordprocessingml.document")
     return $pkg

And there you have it!  To the Server and back again!  Kind of like the Hobbit, but you didn’t need Gandalf or a bunch of dwarves to help you make the journey.

That should be more than enough to get you started, and to continue with something super awesome, just ponder this: when you have a solid understanding of the document format you’re working with, you can generate  Word, Excel, PowerPoint, OpenOffice, InDesign4, and any other document type on the Server, and you don’t even need the original application to start with! We can generate these documents dynamically, on-the-fly, and serve ‘em up to our users who use these applications, but to us on the Server, it’s just a set of XML and related parts.  Cheers!

Microsoft Việt Nam tặng 26 cuốn sách “Open XML – Ngôn ngữ đặc tả dành cho tài liệu văn phòng” của tác giả Wouter van Vugt. Microsoft Việt Nam sẽ gửi tặng cho các công ty có quan tâm hoặc lập trình liên quan đến xử lý tập tin OpenXML ví dụ như tìm kiếm, nén, phân tích tập tin.

Giới thiệu nội dung sách:

Ngôn ngữ đặc tả dữ liệu văn phòng Open XML đã được nhiều người làm công tác tin học ở Việt Nam biết đến như một trong những biến thể của ngôn ngữ dữ liệu XML phổ dụng hiện nay. Open XML cung cấp một môi trường mở và chuẩn hóa được xây dựng trên rất nhiều chuẩn sẵn có như XML, ZIP và Xml-Schema. Vì những kỹ thuật này xâm nhập vào tất cả các nền tảng được sử dụng hiện nay, tài liệu sẽ không còn là một hộp đen chứa dữ liệu định dạng. Thay vào đó, tài liệu đã trở thành dữ liệu. Dễ dàng cho việc tích hợp vào các qui trình kinh doanh. Open XML cung cấp một số công nghệ mới cho phép các dữ liệu kinh doanh có thể được biểu hiện bên ngoài thành chính tài liệu nhằm dễ dàng hơn cho việc truy cập đến những vùng quan trọng và việc tái sử dụng tài liệu.

Cùng với sự phổ biến rộng khắp của các định dạng tài liệu văn phòng trong bộ công cụ Microsoft Office, việc áp dụng Open XML là một hướng mở, chuẩn hóa đáp ứng yêu cầu của đa số người dùng. Tuy vậy, cho đến nay nước ta chưa có một tài liệu nghiêm túc và đầy đủ về Open XML. Một tập thể cán bộ của Viện Công nghệ Thông tin kết hợp với Microsoft Việt Nam đã dịch cuốn “Open XML – Ngôn ngữ đặc tả dành cho tài liệu văn phòng” của tác giả Wouter van Vugt nhằm mục đích cung cấp cho người sử dụng và các nhà phát triển phần mềm những kiến thức cơ bản về Open XML.

Mục tiêu của cuốn sách này là cung cấp cho bạn những khối ghép cần thiết cho việc xây dựng các giải pháp xoay quanh tài liệu. Trong cuốn sách này bạn sẽ khám phá những cơ sở của WordprocessingML, SpreadsheetML và PresentationML cùng với ngôn ngữ hỗ trợ DrawingML; học về cách dùng chỉ dấu biệt chế cho phép các ứng dụng dùng WordprocessingML, các công thức của SpreadsheetML hoặc các hiệu ứng đồ họa tuyệt vời của DrawingML. Cuốn sách sẽ có ích cho rất nhiều nhà kiến trúc phần mềm, người phát triển có nhu cầu xây dựng các giải pháp xoay quanh tài liệu muốn xây dựng các giải pháp gia tăng dựa trên nền tảng Open XML.

Click vào đây để đăng ký nhận sách OpenXML từ Microsoft Việt Nam

Some time we need data from Dataset into Sqlserver for insertion or updation in the Sqlserver Tables.

For example if you need to insert an image then you can use this method to insert the data in Sqlserver tables.

Today, I will explain how to get data from Dataset into Sqlserver Table.

– Code for .Net

Dim ds as new Dataset

Dim dt as new Table

dt.TableName = “MyTable”

ds.Tables.add(dt)

Dim lStrWriter As New StringWriter

Dim lStr As String

ds.WriteXML(lStrWriter)

lstr = lStrWriter.Tostring

Pass this lstr variable to the procedure as parameter – @xmldoc.

Now write the code procedure to get the data from Dataset.

— Code in Sqlserver Store Procedure

CREATE PROCEDURE [dbo].[TestXML]

@xmldoc text — Give Text datatype for getting xml from dataset

as

———Read the Datset  From XML —————–

– call sp_xml_preparedocument

DECLARE @idoc int

EXEC sp_xml_preparedocument @idoc OUTPUT, @xmldoc

SELECT * into #TestTable

FROM OPENXML (@idoc, ‘/NewDataSet/MyTable’,2)

WITH (pk_Userid  BigInt,

UserName  Varchar(10))

EXEC sp_xml_removedocument @idoc

———- End Read ———-

END

BY the use of this procedure you get all the data from dataset in to the ”#Testtable” and we can use this as Sqlserver table in procedure.

I hope this article will be useful to you, Please give feedback on this article.

I have just learned an interesting thing. Someone has sent me a MSWord2007 document in an email. Without really thinking about it I replied that I could not open it and asked for a Word97 version. But then, just for curiosity I clicked on the attachment and to my amazement it opened with OpenOffice! And it wasn’t the latest OOo version it was 2.4 included in Ubuntu Intrepid.

Dica de Leitura:

Para os descrentes, a prova definitiva: O OpenXML ainda não estava (e não está) pronto – homembit

There is a probability of encountering the need to pass an array of data from a front end .NET/FLEX application or WCF/SOA Web Service at some point during the development process for an application.  For example, perhaps you are developing an online order entry system which will require that multiple items from your application get written to the order header and order details tables.

There are a few ways to do this through T-SQL/stored procedures, but the two primary approaches are to:  (l)  create user functions that parse a delimiter to separate the elements in a string;  (2) use the XML features available in Microsoft SQL Server.

If you are using SQL Server 6.5/7.0,  the XML features won’t be available. so you’ll need to go the route of user defined functions.  This post does not address these methods, but here is my favorite link on the topic.

If you are using SQL Server 2000,  the tools available for use are the legacy OPENXML rowset provider and the system stored procedures: sp_xml_preparedocument,  sp_xml_removedocument .  In SQL Server 2005 and 2008, these tools still exist, however the preferred XML data type methods for these versions of SQL Sever are: nodes(), value(), and query().  Here are two excellent posts for anyone working with OPENXML (or data arrays) in SQL Server 2000:

http://vyaskn.tripod.com/passing_arrays_to_stored_procedures.htm

http://www.mssqltips.com/tip.asp?tip=1609

In this practical Order Header/Order Detail example, I’ll be using the xml data type methods: value() and nodes().  To view the relational design pattern used for this example, Fernando Loranzo’s Introduction to Relational Database Design article illustrates the OrderHeader and OrderDetails tables with  Order and Order_Items tables.

T-SQL/Stored Procedure

This procedure accepts two basic parameters, the account id (@AccountID) of the customer and the product items/product quantities bound passed as an xml document  (@OrderList). For the OrderHeader table, the identity feature of SQL Server is invoked on an insert creating a unique OrderID. The OrderID is captured in the declared variable (@OrderID) for use when inserting the product/quantity data into the OrderDetails table. To do the insert, the sub-select uses the OrderList xml document (as ‘D’), drilling through the nodes (/Order/Item/Prod) to parse through the document, obtaining the values (e.g. D.element.value).

create proc [dbo].[InsertOrder]
(
@OrderList xml,
@AccountID int
)

as

set nocount on

declare @OrderID int
declare @Today datetime

set @Today = getDate()

insert into [dbo].[OrderHeader]
(CustAcct,OrderDate)
values
(@AccountID,@Today)

set @OrderID = SCOPE_IDENTITY()

insert into [dbo].[OrderDetail]
(OrderID,ProdId,ProdQty)
select
@OrderID,
D.element.value(‘@ID’, ‘nvarchar(255)’) as ID,
D.element.value(‘@Qty’,'nvarchar(255)’) as Qty
from @OrderList.nodes(‘/Order/Item/Prod) as D(element)

XML for the OrderList

In order for the stored procedure InsertOrder to work, the xml which is passed (@OrderList)  is in the following format:

<Order>
<Item>
<Prod ID=”60000″ Qty=”200″></Prod>
</Item>
<Item>
<Prod ID=”60180″ Qty=”1000″></Prod>
</Item>
</Order>

To test this stored procedure:

Open a query window and type the execute statement, wrapping the OrderList xml in single quotes and the customer number/account id in single quotes (optional as AccountID is defined as an integer).

exec InsertOrder
‘<Order>
<Item>
<Prod ID=”60000″ Qty=”200″></Prod>
</Item>
<Item>
<Prod ID=”60180″ Qty=”1000″></Prod>
</Item>
</Order>’, ‘222333‘

Copyright © Paula DiTallo 2009 All Rights Reserved

kemarin di kantor saia menyarankan big boz  agar sebaiknya meninggalkan micro$ft opis.. kemudian beliau pun menyanggupi dengan catatan

oke boleh aja pindah ke open office, tapi banyak dokum udah terlanjut dibuat dengan opis 2007 (*.docx), kalo open office bisa membukanya boleh saja..

berarti cuma ada satu jalan… buka docx di open office..!!!

dengan gaga berani saia membuka open office yang udah lengket di hardy heron..

yup open office 2.4,, belum support ke docx .. .:(

setelah googling sana sini.. nyari bahan buat tambalan.. akhirnya nemu juga untuk platform debian / ubuntu…

dengan senyum manis gue buka console..

kita unduh dulu OdfConverter

wget http://blog.mypapit.net/imej/odf_filter.tar.bz2

setelah di ekstrak… akan muncul 4 file yang keren2..

MOOXFilter_cpp.xcu, MOOXTypeDetection.xcu, OdfConverter and README.txt

masukkan kata2 mutiara dari mbah papit

sudo cp OdfConverter /usr/lib/openoffice/program/

sudo cp MOOXFilter_cpp.xcu usr/lib/openoffice/share/registry/modules/org/openoffice/TypeDetection/Filter/

sudo cp MOOXTypeDetection.xcu /usr/lib/openoffice/share/registry/modules/org/openoffice/TypeDetection/Types/

yip yip.. sepertinya berjalan baik baik saja… setelah open offie kita restart…

adakadabra… si docx lahir dengan sehat…

Aquí un Tip, para colocar el cursor el inicio del Documento. Esto lo hacemos con una sola línea de código que es:

Word.Selection.HomeKey(Microsoft.Office.Interop.Word.WdUnits.wdStory, False)

El segundo parámetro nos indica si vamos a seleccionar el texto, si lo colocamos en True, selecciona desde el punto donde se encontraba el puntero hasta el inicio.

Aquí un tip más si quieren saber el tipo de datos lo hacen con esta instrucción:

miBD.TableDefs("Alumnos").Fields("ID").Type

El objeto miBD es de tipo data base que hereda de la clase DAO, para esto debes agregar una referencia al proyecto y después asignarle el tipo de datos de la Aplicacción Access más o menos así:

miBD = Access.CurrentDb

Para saber el formato de tipo de datos es con la siguiente instrucción:

miBD.TableDefs("Alumnos").Fields("ID").Properties("Format").Value

Espero que les sea de utilidad Saludos..

@nor

Que tal, siguiendo con estos mini ejemplos de programación en Office, mientras pasa el tiempo, y en base a una pregunta eh aquí el como identificar en que página se encuentra el cursor en un Documento de Word.

El ejemplo siguiente es muy sencillo pero hice un menú para que pudieran apreciar el funcionamiento. Contiene un menú con las opciones:

1. Abrir un Documento
2. Mover el Cursor
3. Cerrar Documento

El código es el siguiente.

Imports Word = Microsoft.Office.Interop.Word

Module Module1

    Public word As Word.Application
    Sub Main()
        word = New Word.Application
        Menu()
        Dim valor As Integer
        Do
            Try
                valor = Integer.Parse(Console.ReadLine())
            Catch ex As Exception
                Console.WriteLine(ex.Message)
            End Try
            Proceso(valor)
            Console.Clear()
            Menu()
        Loop While valor <> 4

    End Sub

    Public Sub Menu()
        Console.WriteLine("1.- Abrir Documento")
        Console.WriteLine("2.- Mover Cursor")
        Console.WriteLine("3.- Cerrar el Documento")
        Console.WriteLine("4 Cerrar Aplicación")
        Console.Write("Selecciona alguna Opción :")
    End Sub

    Public Sub AbrirDocumento(ByVal val As Boolean)

        If val = False Then
            word.Documents.Open("C:\Demo.docx")
            word.Application.Visible = True
        Else
            word = word.ActiveDocument.Application
            For i As Integer = 1 To word.Selection.Information _
                (Microsoft.Office.Interop.Word.WdInformation.wdNumberOfPagesInDocument)
                If word.Selection.Information _
                (Microsoft.Office.Interop.Word.WdInformation.wdActiveEndPageNumber) = i Then
                    Console.WriteLine("El Cursor esta en la página: {0} ", i)
                End If
            Next
        End If
    End Sub

    Public Sub CerrarDocumento()

        For Each doc As Word.Document In word.Documents
            doc.Close(SaveChanges:=False)
        Next
        word.Application.Quit()

    End Sub

    Public Sub Proceso(ByVal id As Integer)
        Select Case id
            Case 1
                AbrirDocumento(False)
            Case 2
                Console.Clear()
                AbrirDocumento(True)
                Console.ReadLine()
            Case 3
                CerrarDocumento()
        End Select
    End Sub

End Module

Explicando el Código.

El primer método es el de Menú, que solo contiene las opciones que se muestran en pantalla.

Lugo esta el método de Abrir un documento, que consta de 2 etapas en base a una condición sencilla, recibe un variable booleana que según el valor es la acción que realiza. Con la opción uno solo abre el documento llamad Demo.docx que esta en la unidad C. En la opción 2 muestra un mensaje en la consola que indica que página esta el puntero.

El método de Cerrar el documento. (Sin comentarios)

Por ultimo el de proceso que evalúa que es lo que el usuario eligió.

La parte importante de este post es el saber como identificar en que página esta el puntero y esto se encuentra en el método AbrirDocumento y el código es este:

For i As Integer = 1 To word.Selection.Information _
                (Microsoft.Office.Interop.Word.WdInformation.wdNumberOfPagesInDocument)
                If word.Selection.Information _
                (Microsoft.Office.Interop.Word.WdInformation.wdActiveEndPageNumber) = i Then
                    Console.WriteLine("El Cursor esta en la página: {0} ", i)
                End If
            Next

Que recorremos la cantidad total de páginas del documento y obtenemos en que página esta puntero con la instrucción:

word.Selection.Information _
                (Microsoft.Office.Interop.Word.WdInformation.wdActiveEndPageNumber)

Recuerden que para que funcione deben tener el archivo llama Demo.docx en su unidad D o colocar la ruta en donde se encuentre. Saludos.

@nor

Ya es el tercer post sobre esto, y a petición de un comentario de mi amigo David. Solo una pequeña modificación para cerrar los documentos de Word. Les platico a lo que se refiere y porque publico este post. Resulta que trabajamos con objetos de Word, validación de eventos sobre el Office 2007 y muchas veces tenemos la necesidad de reiniciar una aplicación de Office sin guardar cambios, pero resulta que sino controlamos bien la liberación de los recursos o de los objetos nos puede traer varios errores.

Lo que me preguntaron es como cerrar todos las instancias de Word, pero sin hacerlo desde los procesos como lo menciono en otro post, es decir que pasa si abro un archivo cualquiera y después creo un instancia (desde código) y necesito validar no se… que se cierren todos los documentos, o que se guarden con nombres específicos, que se yo.

En el siguiente ejemplo cerramos absolutamente todos los documentos sin importar la instancia.

Imports Word = Microsoft.Office.Interop.Word

Module Module1

    Sub Main()

        'Variables
        Dim AppWord As New Word.Global
        Dim doc As Word.Document

        'Aquí cerramos todos los documentos sin guardar cambios
        For Each doc In AppWord.Documents
            doc.Close(SaveChanges:=False)
        Next

        AppWord.Application.Quit(SaveChanges:=False)

    End Sub

End Module

Si se dan cuenta es muy similar a lo que publique en el post de cerrar los documentos a partir de una instancia, pero  aquí hacemos referencia a la aplicación Global, esa es la diferencia para poder cerrar todos los documentos de Word que se encuentren abiertos en nuestro Sistema.

Para ver que funciona, prueben abriendo varios archivos de Word y luego ejecuten el programa, verán que se cierran todos sin guardar cambios.

Saludos.

@nor

En el post anterior vimos como cerrar los objetos de Word en base a la lista del proceso del Sistema. En este ejemplo vamos a ver como cerrarlos a partir de una instancia, esto lo podemos usar cuando trabajamos con objetos de Word para verificar que el usuario haga algo o que se yo, pero aquí el ejemplo.

Imports Word = Microsoft.Office.Interop.Word

Module Module1

    Sub Main()

        'Variables
        Dim AppWord As New Word.Application
        Dim doc As Word.Document

        'Agregamos cuatro documentos en blanco y escribimos un texto
        For i As Integer = 0 To 4
            AppWord.Documents.Add()
            AppWord.Application.WindowState = Word.WdWindowState.wdWindowStateNormal
            AppWord.Visible = True
            AppWord.ActiveDocument.Sections(1).Range.Text = "Mi Documento numero:  " & i
        Next

        'Aquí cerramos todos los documentos sin guardar cambios
        For Each doc In AppWord.Documents
            doc.Close(SaveChanges:=False)
        Next
        AppWord.Quit(SaveChanges:=False)

    End Sub

End Module

Explicando el código.

Primero creamos una instancia de Word y un documento para poder hacer el recorrido por el arreglo de Documentos abiertos.

En el For creamos 5 documentos maximizamos la ventana y la mostramos, al mismo  tiempo que agregamos un texto al mismo.

Después por medio del For each recorremos todos los documentos que creamos (incluso sirve si los abrimos), los cerramos sin guardar cambios.

Por ultimo cerramos nuestra instancia de Word.

Espero que les sea de utilidad.

Saludos.

@nor.

Muchas veces tenemos la necesidad de cerrar o tronar los procesos de un objeto de Office, en este caso de Word. El siguiente ejemplo muestra como hacer.

Imports System.Diagnostics

Module Module1

    Sub Main()
        Dim procs() = Process.GetProcesses
        Dim pr As Process
        For Each pr In procs
            If (pr.ProcessName = "WINWORD") Then
                pr.Kill()
            End If
        Next

    End Sub

End Module

Utilizamos el nombre de espacios Diagnostics, que nos permite obtener los procesos que se están ejecutando en el Sistema. lo que hacemos es obtener un arreglo de dichos procesos para después recorrerlos e identificar cuales son los que queremos tronar. Por ultimo ejecutamos el método Kill el cual detiene inmediatamente el proceso asociado.

Espero que les sea de utilidad, y como se observa en el ejemplo podemos aplicar esto a cualquier proceso, e incluso ejecutar algún otro que no este corriendo.

Saludos.

Este es el primer post de una serie (espero que sea larga) en donde hablare de como trabajar un poco con VSTO desde .NET, realmente son ejemplos sencillos pero espero que les sean de utilidad sobre todo cuando trabajan con documentos de Office y necesitan optimizar algunos procesos. Iniciamos con el los Estilos en Word

¿Cómo asignar un Estilo rápido a un párrafo en Word?

Public Sub AsignarEstilo(ByVal doc As Word.Document, ByVal nomEstiloRapido As String, ByVal numParrafo As Integer)
        Dim s As Word.Style

        For Each s In doc.Styles
            If s.QuickStyle Then
                If s.NameLocal = nomEstiloRapido Then
                    doc.Paragraphs(numParrafo).Range.Style = s
                End If
            End If
        Next
    End Sub

Explicando el método. Recorremos todo el arreglo de estilos con los que cuenta un Documento de Word, utilizando la propiedad QuickStyle para identificar los estilos rápidos, como el método recibe el nombre del Estilo rápido lo comparamos y para asignarlo al párrafo que le indicamos cuando llamamos al método.

Empecemos a Usar Open Office:

Como muchos de nosotros sabemos Microsoft ha ganado para establecer un nuevo formato denominado OpenXML (no se QUE puede tener de abierto) pero la nueva ISO ya esta definida.

El Objetivo de este post es que empecemos a animarnos a utilizar herramientas libres y no necesariamente estoy hablando de Linux, sino de empezar a utilizar por ejemplo Open Office, seguro ahora ustedes dirán que las Herramientas de Microsoft son mejores por ser pagas y donde la mayoría de nosotros teníamos que creackerlas o conseguir un serial trucho, bueno la idea es empezar a legalizarnos y liberarnos de los formatos, estándares y programas de microsoft y empezar a probar otras aplicaciones ofimáticas donde no tengamos que guardar nuestros documentos en raros formatos como docx y tampoco tengamos que preocuparnos por actualizar el crack cada mes.

Aca les dejo algunas razones de la dudosa libertad de OpenXML:

1-Ya hay un estándar, ISO 26300, llamado Open Document Format (ODF): un doble estándar supondrá incertidumbre, confusión y un coste añadido para la industria, gobiernos y ciudadanos.;

2- No hay ninguna implementación de referencia de la especificación de OOXML: Microsoft Office 2007 produce una versión especial de OOXML que no cumple con la especificación de OOXML propuesta en ISO;

3- En el documento de especificación falta información como, por ejemplo, cómo implementar un “autoSpaceLikeWord95” o un “useWord97LineBreakRules”;

4- Más del 10% de los ejemplos de su especificación no validan la conformidad con XML;

No existe garantía alguna para que cualquiera pueda implementar parcial o totalmente la especificación de OOXML sin arriesgarse a que Microsoft le exija daños y perjuicios por infracción de patentes o el pago de licencias de patentes;

4- Esta propuesta de estándar entra en conflicto con otros estándares ISO, como ISO 8601 (representación de fechas y tiempos), ISO 639 (códigos de representación de nombre e idiomas) o ISO/IEC 10118-3 (funciones hash de criptografía);

5- Hay un error en la especificación del fichero de formatos de hoja de cálculo que impide introducir cualquier fecha previa al año 1900. Esto es un error que se arrastra desde las obsoletas versiones de 16bits de la aplicación MS-Office;

6- Esta propuesta de estándar no ha sido creada aunando la experiencia y mejores prácticas de todas las partes interesadas (tales como productores, distribuidores, consumidores, usuarios y reguladores), sino por Microsoft en solitario.

Descargate Open Office pinchando en la Imagen:

Un estándar debe estar totalmente documentado públicamente. Además, su proceso de estandarización (ECMA) debería haber garantizado que todas las patentes de los proponentes del mismo fueran desveladas y licenciadas como mínimo en términos RAND. Finalmente, es necesario que una propuesta de estándar ISO cumpla y no contradiga los estándares ISO ya preexistentes para no obligar a “reinventar la rueda”. Office OpenXML no cumple ninguna de esas condiciones.

Visita el enlace:

http://www.openxml.info/

Dile NO al formato de Microsoft Office como estándar ISO

http://www.noooxml.org/petition-es/

Solicito a los miembros del comité nacional de ISO que voten “NO” a ISO DIS 29500 (formato documental Office OpenXML, OOXML) y aporto las siguientes razones principales: