Conectar um item no Data Store a um banco de dados SQL Server
O Word permite que você gere documentos criando soluções baseadas em dados. Você pode criar um documento de modelo que inclui uma parte XML personalizada e usar controles de conteúdo para associar a dados XML personalizados usando o mapeamento XML. Embora o modelo de termo seja usado neste contexto, este documento não é um modelo do Word, mas compartilha algumas características de um documento de modelo do Word. Em seguida, você pode criar um aplicativo gerenciado baseado na Web para criar um novo documento com base no documento de modelo. O aplicativo gerenciado baseado na Web abre o documento de modelo, recupera dados de um banco de dados do Microsoft SQL Server para criar uma nova parte XML personalizada, substitui a parte XML personalizada do documento de modelo pela nova parte e salva o documento de modelo como um novo documento do Word.
Este passo a passo explica como criar um novo documento de modelo e como criar um aplicativo do lado do servidor que gere documentos que exibem dados armazenados em um banco de dados do Microsoft SQL Server. Para criar este aplicativo, você concluirá as duas tarefas a seguir:
Crie um documento de modelo do Word.
Crie um aplicativo baseado na Web do lado do servidor que extraia dados de um banco de dados do Microsoft SQL Server e gere novos documentos com base no documento de modelo do Word.
Os objetos programáticos usados neste exemplo são os seguintes:
CustomXMLPart (no modelo de objeto principal do sistema do Microsoft Office)
CustomXMLParts (no modelo de objeto principal do sistema do Microsoft Office)
Para obter mais informações sobre os controles de conteúdo, consulte Trabalhando com controles de conteúdo.
Cenário de negócios: criar um gerador de documentos do cliente
Para criar um gerador de documentos do Word que conecta um item no armazenamento de dados a um banco de dados do Microsoft SQL Server, primeiro você cria um documento de gerador de cartas do cliente de modelo que contém controles de conteúdo que mapeiam para um arquivo XML. Em seguida, você cria um aplicativo baseado na Web de geração de documentos que permite selecionar um nome da empresa para gerar um documento personalizado. O aplicativo recupera dados do cliente de um banco de dados do Microsoft SQL Server e usa o gerador de cartas do cliente para criar um novo documento que exibe dados do cliente com base em uma seleção de usuário. O documento exibe as seguintes informações:
- Nome da Empresa
- Nome de contato
- Título de contato
- Telefone
Use as etapas gerais a seguir para criar um gerador de documentos do Word.
Para criar um gerador de documentos personalizado e definir os mapeamentos XML para cada controle de conteúdo
Abra o Word e crie um documento em branco.
Adicione controles de conteúdo de texto simples ao documento para associar a nós no armazenamento de dados.
Os controles de conteúdo são partes predefinidas de conteúdo. O Word oferece vários tipos de controles de conteúdo. Isso inclui blocos de texto, caixas de seleção, menus suspensos, caixas de combinação, controles de calendário e imagens. Você pode mapear esses controles de conteúdo para um elemento em um arquivo XML. Usando expressões XPath , você pode mapear conteúdo programaticamente em um arquivo XML para um controle de conteúdo. Isso permite que você escreva um aplicativo simples e curto para manipular e modificar dados em um documento.
Para adicionar um controle de conteúdo, na guia Desenvolvedor , no grupo Controles , clique em Controle de Conteúdo de Texto Simples.
Adicione quatro controles de conteúdo de texto simples ao documento. Depois de adicionar cada controle, atribua a cada um um título: clique no controle; no grupo Controles , clique em Propriedades; na caixa Título , digite um título para o controle, conforme mostrado na lista a seguir; e clique em OK.
- Nome da Empresa
- Nome de contato
- Título de contato
- Telefone
Você também pode usar o código VBA (Visual Basic for Applications) a seguir para adicionar controles de conteúdo ao documento. Pressione ALT+F11 para abrir o editor do Visual Basic, cole o código na janela de código, clique em qualquer lugar do procedimento e pressione F5 para executar o código e adicione quatro controles de conteúdo ao documento de modelo.
Sub AddContentControls() Selection.Range.ContentControls.Add (wdContentControlText) Selection.ParentContentControl.Title = "Company Name" Selection.ParentContentControl.Tag = "Company Name" Selection.MoveDown Unit:=wdLine, Count:=1 Selection.TypeParagraph Selection.Range.ContentControls.Add (wdContentControlText) Selection.ParentContentControl.Title = "Contact Name" Selection.ParentContentControl.Tag = "Contact Name" Selection.MoveDown Unit:=wdLine, Count:=1 Selection.TypeParagraph Selection.Range.ContentControls.Add (wdContentControlText) Selection.ParentContentControl.Title = "Contact Title" Selection.ParentContentControl.Tag = "Contact Title" Selection.MoveDown Unit:=wdLine, Count:=1 Selection.TypeParagraph Selection.Range.ContentControls.Add (wdContentControlText) Selection.ParentContentControl.Title = "Phone Number" Selection.ParentContentControl.Tag = "Phone Number" Selection.MoveDown Unit:=wdLine, Count:=1 Selection.TypeParagraph End SubDefina o mapeamento XML nos controles de conteúdo.
O mapeamento XML é um recurso do Word que permite criar um link entre um documento e um arquivo XML. Isso cria uma separação real de dados/modos de exibição entre a formatação de documento e os dados XML personalizados.
Para carregar uma parte XML personalizada, primeiro você deve adicionar um novo armazenamento de dados a um objeto Document usando o método Add da coleção CustomXMLParts . Isso acrescenta um novo armazenamento de dados vazio ao documento. Como ele está vazio, você ainda não pode usá-lo. Em seguida, você deve carregar uma parte XML personalizada de um arquivo XML no armazenamento de dados, chamando o método Load do objeto CustomXMLPart que usa um caminho válido para um arquivo XML como parâmetro.
Salve o documento, nomeando-o CustomerLetterGenerator.docm.
Observação
Como ele contém código VBA, você deve salvar o documento como um arquivo de documento habilitado para macro (.docm).|
O procedimento a seguir explica como mapear um controle de conteúdo para um arquivo XML personalizado de exemplo. Você cria um arquivo XML personalizado válido, salva o arquivo e usa Visual Basic for Applications código (VBA) para adicionar ao documento de modelo um armazenamento de dados que contém as informações às quais você deseja mapear.
Para definir um mapeamento XML em um controle de conteúdo
Crie um arquivo de texto e salve-o como CustomerData.xml.
Copie o código XML a seguir no arquivo de texto e salve o arquivo.
<?xml version="1.0"?> <Customer> <CompanyName>Alfreds Futterkiste</CompanyName> <ContactName>Maria Anders</ContactName> <ContactTitle>Sales Representative</ContactTitle> <Phone>030-0074321</Phone> </Customer>Pressione ALT+F11 para abrir o editor do Visual Basic, cole o código a seguir na janela de código, clique em qualquer lugar do procedimento e pressione F5 para executar o código e anexar um arquivo XML ao documento de modelo para que ele se torne um item de armazenamento de dados disponível.
Public Sub LoadXML() ' Load CustomerData.xml file ActiveDocument.CustomXMLParts.Add ActiveDocument.CustomXMLParts(ActiveDocument.CustomXMLParts.Count).Load ("C:\CustomerData.xml") End SubObservação
Há pelo menos três partes XML personalizadas padrão que são sempre criadas com um documento: 'Páginas de cobertura', 'Propriedades doc' e 'propriedades de aplicativo'. Além disso, várias outras partes XML personalizadas podem ser criadas em um determinado computador, dependendo de vários fatores. Estes incluem quais complementos são instalados, conexões com o SharePoint e assim por diante. Chamar o método Add na coleção CustomXMLParts no código anterior adiciona uma parte XML adicional, na qual o arquivo XML é carregado. É nessa parte que o método Load é chamado, na próxima linha de código.
Para determinar o número de índice da parte na qual carregar o arquivo XML, é necessário passar a contagem de partes XML personalizadas para o método Load .
ActiveDocument.CustomXMLParts(ActiveDocument.CustomXMLParts.Count).Load ("C:\CustomerData.xml")Defina um mapeamento XML em um controle de conteúdo que se refere a um nó no armazenamento de dados adicionado.
Para criar um mapeamento XML, use uma expressão XPath que aponta para o nó na parte de dados XML personalizada para a qual você deseja mapear um controle de conteúdo. Depois de adicionar um armazenamento de dados ao documento (e o armazenamento de dados apontar para um arquivo XML válido), você estará pronto para mapear um de seus nós para um controle de conteúdo.
Para fazer isso, passe uma Cadeia de Caracteres que contém um XPath válido para um objeto ContentControl usando o método SetMapping do objeto XMLMapping (usando a propriedade XMLMapping do objeto ContentControl ). Abra o editor do Visual Basic e execute o código VBA a seguir para associar controles de conteúdo a itens no armazenamento de dados.
Public Sub MapXML() Dim strXPath1 As String strXPath1 = "/Customer/CompanyName" ActiveDocument.ContentControls(1).XMLMapping.SetMapping strXPath1 Dim strXPath2 As String strXPath2 = "/Customer/ContactName" ActiveDocument.ContentControls(2).XMLMapping.SetMapping strXPath2 Dim strXPath3 As String strXPath3 = "/Customer/ContactTitle" ActiveDocument.ContentControls(3).XMLMapping.SetMapping strXPath3 Dim strXPath4 As String strXPath4 = "/Customer/Phone" ActiveDocument.ContentControls(4).XMLMapping.SetMapping strXPath4
Criar um aplicativo Server-Side que extrai dados de um banco de dados SQL Server e gera um novo documento
Você pode criar um aplicativo baseado na Web que permite que os usuários selecionem um nome da empresa e gerem uma carta personalizada. O aplicativo baseado na Web recupera dados do cliente de um banco de dados SQL Server, abre o documento de modelo de carta do cliente e cria um novo documento que exibe dados do cliente com base em uma seleção de usuário. Este aplicativo baseado na Web não requer o uso do Word ou do VBA. Use o idioma de código gerenciado favorito (Visual Basic .NET ou C#) para criar este aplicativo.
Observação
O aplicativo baseado na Web mostrado aqui obtém seus dados do banco de dados Northwind.mdf. Esse banco de dados foi instalado com versões anteriores do SQL Server e do Office. Se você não tiver o banco de dados Northwind em seu computador, poderá baixá-lo do seguinte site: banco de dados Northwind
Para criar um aplicativo do lado do servidor que extraia dados de um banco de dados SQL Server e gera um novo documento
Abra o Visual Studio ou o Visual Web Developer.
Crie um aplicativo Web ASP.NET e nomeie-o sqlServerSample.
Nas etapas a seguir, você conectará o aplicativo Web ASP.NET a um banco de dados SQL Server.
Adicione a cadeia de conexão a seguir ao arquivo Web.config em seu projeto do Visual Studio.
<connectionStrings> <add name="NorthwindConnectionString" connectionString="data source=(local);database=Northwind; integrated security=SSPI;persist security info=false;" providerName="System.Data.SqlClient" /> </connectionStrings>Em seu projeto do Visual Studio, adicione o documento CustomerLetterGenerator.docm à pasta App_Data : clique com o botão direito do mouse em App_Data, aponte para Adicionar, clique em Item Existente, navegue até o local em que você salvou o documento, selecione-o e clique em Adicionar.
Adicione uma referência a WindowsBase.dll ao seu projeto: clique com o botão direito do mouse em Referências, clique em Adicionar Referência, clique na guia .NET , selecione WindowsBase e clique em OK.
Baixar e instalar o Microsoft .NET Framework 4.0
Configure o assembly no arquivo Web.config da seguinte maneira.
<compilation debug="false"> <assemblies> <add assembly="WindowsBase, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35"/> </assemblies> </compilation>Adicionar um Formulário Web ao seu projeto: no menu Projeto , clique em Adicionar Novo Item; em Modelos Instalados, clique em Web; selecione Formulário Web e clique em Adicionar.
No Gerenciador de Soluções, clique com o botão direito do mouse em Propriedades e clique em Abrir.
Na guia Web , em Iniciar Ação, selecione Página Específica, clique no botão procurar e navegue até a página WebForm1.aspx.
Adicione o código a seguir ao arquivo WebForm1.aspx , substituindo a parte do arquivo delimitada pelas marcas de abertura e fechamento
<html>.<html xmlns="https://www.w3.org/1999/xhtml"> <head runat="server"> <title>Data-Driven Document Generation - SQL Server Sample</title> </head> <body> <form id="form1" runat="server"> <div> <h1>Customer Letter Generator</h1> <table border="0" cellpadding="0" cellspacing="0" style="width: 100%; height: 12%"> <tr> <td> Choose a customer:</td> <td> <asp:DropDownList ID="ddlCustomer" runat="server" AutoPostBack="True" DataSourceID="CustomerData" DataTextField="CompanyName" DataValueField="CustomerID" Width="301px"> </asp:DropDownList> <asp:SqlDataSource ID="CustomerData" runat="server" ConnectionString="<%$ ConnectionStrings:NorthwindConnectionString %>" SelectCommand="SELECT [CustomerID], [CompanyName] FROM [Customers]" ProviderName="<%$ ConnectionStrings:NorthwindConnectionString.ProviderName %>"> </asp:SqlDataSource> </td> </tr> </table> </div> <br /> <asp:Button ID="Button1" runat="server" OnClick="SubmitBtn_Click" Text="Create Letter" Width="123px" /> </form> </body> </html>Dependendo da linguagem de codificação que você usa, adicione o código .NET ou C# do Visual Basic a seguir à página de código do WebForm1.aspx apropriada em seu projeto.
Código de exemplo: Visual Basic .NET
O exemplo do .NET do Visual Basic a seguir mostra como associar a um banco de dados SQL Server para recuperar dados com base em uma seleção do cliente e criar um novo documento com base no documento de modelo CustomerLetterGenerator.docm. Adicione o código a seguir ao arquivo WebForm1.aspx.vb , substituindo o código existente no arquivo.
Imports System.Collections.Generic
Imports System.Data
Imports System.Data.SqlClient
Imports System.IO
Imports System.IO.Packaging
Imports System.Linq
Imports System.Xml
Imports System.Web
Imports System.Web.UI
Imports System.Web.UI.WebControls
Public Class WebForm1
Inherits System.Web.UI.Page
Protected Sub Page_Load(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Load
End Sub
Private Const strRelRoot As String = "https://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument"
Private Sub CreateDocument()
' Get the template document file and create a stream from it
Const DocumentFile As String = "~/App_Data/CustomerLetterGenerator.docm"
' Read the file into memory
Dim buffer() As Byte = File.ReadAllBytes(Server.MapPath(DocumentFile))
Dim memoryStream As MemoryStream = New MemoryStream(buffer, True)
buffer = Nothing
' Open the document in the stream and replace the custom XML part
Dim pkgFile As Package = Package.Open(memoryStream, FileMode.Open, FileAccess.ReadWrite)
Dim pkgrcOfficeDocument As PackageRelationshipCollection = pkgFile.GetRelationshipsByType(strRelRoot)
For Each pkgr As PackageRelationship In pkgrcOfficeDocument
If (pkgr.SourceUri.OriginalString = "/") Then
' Get the root part
Dim pkgpRoot As PackagePart = pkgFile.GetPart(New Uri(("/" + pkgr.TargetUri.ToString), UriKind.Relative))
' Add a custom XML part to the package
Dim uriData As Uri = New Uri("/customXML/item1.xml", UriKind.Relative)
If pkgFile.PartExists(uriData) Then
' Delete part "/customXML/item1.xml" part
pkgFile.DeletePart(uriData)
End If
' Load the custom XML data
Dim pkgprtData As PackagePart = pkgFile.CreatePart(uriData, "application/xml")
GetDataFromSQLServer(pkgprtData.GetStream, ddlCustomer.SelectedValue)
End If
Next
' Close the file
pkgFile.Close()
' Return the result
Response.ClearContent()
Response.ClearHeaders()
Response.AddHeader("content-disposition", "attachment; filename=document.docx")
Response.ContentEncoding = System.Text.Encoding.UTF8
memoryStream.WriteTo(Response.OutputStream)
memoryStream.Close()
Response.End()
End Sub
Private Sub GetDataFromSQLServer(ByVal stream As Stream, ByVal customerID As String)
'Connect to a SQL Server database and get data
Dim source As String = ConfigurationManager.ConnectionStrings("NorthwindConnectionString").ConnectionString
Const SqlStatement As String = "SELECT CompanyName, ContactName, ContactTitle, Phone FROM Customers WHERE CustomerID=@customerID"
Dim conn As SqlConnection = New SqlConnection(source)
conn.Open()
Dim cmd As SqlCommand = New SqlCommand(SqlStatement, conn)
cmd.Parameters.AddWithValue("@customerID", customerID)
Dim dr As SqlDataReader = cmd.ExecuteReader
If dr.Read Then
Dim writer As XmlWriter = XmlWriter.Create(stream)
writer.WriteStartElement("Customer")
writer.WriteElementString("CompanyName", CType(dr("CompanyName"), String))
writer.WriteElementString("ContactName", CType(dr("ContactName"), String))
writer.WriteElementString("ContactTitle", CType(dr("ContactTitle"), String))
writer.WriteElementString("Phone", CType(dr("Phone"), String))
writer.WriteEndElement()
writer.Close()
End If
dr.Close()
conn.Close()
End Sub
Protected Sub SubmitBtn_Click(ByVal sender As Object, ByVal e As EventArgs)
CreateDocument()
End Sub
End Class
Código de exemplo: C #
O exemplo de C# a seguir mostra como associar a um banco de dados SQL Server para recuperar dados com base em uma seleção do cliente e criar um novo documento com base no documento de modelo CustomerLetterGenerator.docm. Adicione o código a seguir ao arquivo WebForm1.Aspx.cs , copiando sobre o código existente.
using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
using System.IO;
using System.IO.Packaging;
using System.Linq;
using System.Xml;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
namespace SQLServerSample
{
public partial class WebForm1 : System.Web.UI.Page
{
protected void Page_Load(object sender, EventArgs e)
{
}
private const string strRelRoot = "https://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument";
private void CreateDocument()
{
// Get the template document file and create a stream from it
const string DocumentFile = @"~/App_Data/CustomerLetterGenerator.docm";
// Read the file into memory
byte[] buffer = File.ReadAllBytes(Server.MapPath(DocumentFile));
MemoryStream memoryStream = new MemoryStream(buffer, true);
buffer = null;
// Open the document in the stream and replace the custom XML part
Package pkgFile = Package.Open(memoryStream, FileMode.Open, FileAccess.ReadWrite);
PackageRelationshipCollection pkgrcOfficeDocument = pkgFile.GetRelationshipsByType(strRelRoot);
foreach (PackageRelationship pkgr in pkgrcOfficeDocument)
{
if (pkgr.SourceUri.OriginalString == "/")
{
// Get the root part
PackagePart pkgpRoot = pkgFile.GetPart(new Uri("/" + pkgr.TargetUri.ToString(), UriKind.Relative));
// Add a custom XML part to the package
Uri uriData = new Uri("/customXML/item1.xml", UriKind.Relative);
if (pkgFile.PartExists(uriData))
{
// Delete document "/customXML/item1.xml" part
pkgFile.DeletePart(uriData);
}
// Load the custom XML data
PackagePart pkgprtData = pkgFile.CreatePart(uriData, "application/xml");
GetDataFromSQLServer(pkgprtData.GetStream(), ddlCustomer.SelectedValue);
}
}
// Close the file
pkgFile.Close();
// Return the result
Response.ClearContent();
Response.ClearHeaders();
Response.AddHeader("content-disposition", "attachment; filename=CustomLetter.docx");
Response.ContentEncoding = System.Text.Encoding.UTF8;
memoryStream.WriteTo(Response.OutputStream);
memoryStream.Close();
Response.End();
}
private void GetDataFromSQLServer(Stream stream, string customerID)
{
// Connect to a SQL Server database and get data
String source = System.Configuration.ConfigurationManager.ConnectionStrings["NorthwindConnectionString"].ConnectionString;
const string SqlStatement =
"SELECT CompanyName, ContactName, ContactTitle, Phone FROM Customers WHERE CustomerID=@customerID";
using (SqlConnection conn = new SqlConnection(source))
{
conn.Open();
SqlCommand cmd = new SqlCommand(SqlStatement, conn);
cmd.Parameters.AddWithValue("@customerID", customerID);
SqlDataReader dr = cmd.ExecuteReader();
if (dr.Read())
{
XmlWriter writer = XmlWriter.Create(stream);
writer.WriteStartElement("Customer");
writer.WriteElementString("CompanyName", (string)dr["CompanyName"]);
writer.WriteElementString("ContactName", (string)dr["ContactName"]);
writer.WriteElementString("ContactTitle", (string)dr["ContactTitle"]);
writer.WriteElementString("Phone", (string)dr["Phone"]);
writer.WriteEndElement();
writer.Close();
}
dr.Close();
conn.Close();
}
}
protected void SubmitBtn_Click(object sender, EventArgs e)
{
CreateDocument();
}
}
}
Para obter mais informações sobre como trabalhar com ASP.NET 2.0, consulte https://www.asp.net/get-started/.
Este artigo explica como extrair dados de um banco de dados SQL Server e inseri-los em seu documento de modelo. Você também pode extrair os dados de outras fontes de dados, incluindo, por exemplo, Access e Excel. Para obter mais informações sobre como se conectar a dados nesses aplicativos de forma programática, confira a documentação do desenvolvedor do Access e do Excel.
Suporte e comentários
Tem dúvidas ou quer enviar comentários sobre o VBA para Office ou sobre esta documentação? Confira Suporte e comentários sobre o VBA para Office a fim de obter orientação sobre as maneiras pelas quais você pode receber suporte e fornecer comentários.
Comentários
Em breve: Ao longo de 2024, eliminaremos os problemas do GitHub como o mecanismo de comentários para conteúdo e o substituiremos por um novo sistema de comentários. Para obter mais informações, consulte https://aka.ms/ContentUserFeedback.
Enviar e exibir comentários de