En ocasiones es necesarios decidir que campos deben
ser visualizados en algún reporte ya sea por cuestiones de políticas
de seguridad en una compañía o por comodidad del Usuario Final de
nuestra Aplicación. Este artículo expone una forma de trabajar Reportes
creando y publicando archivos RDL en la
Base de Reporting Service.
Contenido
Definición
Construyendo el RDL (Reporting
Definition Language)
Publicando el Reporte
Conclusión
Definición
Visual Studio nos permite diseñar
visualmente reportes generando finalmente un archivo XML construido en base a Reporting Definition Language (RDL),
Dichos reportes pueden ejecutarse y visualizarse a través Reporting Services quien es que
al final almacena la metadata de los datos que va a
construir el reporte cuando este sea invocado desde alguna aplicación
(Web o Windows)
Reporting Services es un Servicio Web
que expone varios métodos que pueden ser aprovechados para construir,
administrar, publicar y distribuir reportes.
Para el caso en desarrollo tenemos:
MS
SQL Server 2000
Reporting
Services
Visual
Studio .Net 2003
En el caso a desarrollar hemos tomado una
conexión a una Base de Datos y según la tabla elegida
seleccionamos los campos que el reporte debe de mostrar esto generara un RDL el
mismo que será publicado en la
Base de Datos de Reporting Services. Además de permitir realizar la
exportación a formatos básicos como Excel y PDF:
Construyendo el RDL
El RDL define la metadata
del reporte esto al final es una extensión XML que se guía por
una estructura definida para cada área del reporte como el encabezado,
los campos que se muestran en el reporte, los parámetros que este
acepta, etc.
El RDL es un XML que tiene tres elementos básicos
1.
DataSources: Que almacena información sobre la
conexión al Servidor de Base de Datos.
2.
DataSet: Almacena la consulta y los campos empleados en la
consulta, para el caso de Procedimientos Almacenados u otro casa, aquí
se pueden definir los parámetros del reporte
3.
Body: Define toda la presentación del Reporte
(Colores, Tipos de Letra, etc).
Existen mas secciones que el RDL puede mantener
como los Parámetros, Agrupamientos, etc.
A través del XMLTextWriter
podemos generar un Archivo XML que respete la estructura completa de un archivo
RDL.
En el caso de acuerdo a los campos seleccionados
debemos generar el archivo RDL para ello debemos conocer que campos fueron marcados
en el Control List:
private string[] obtenerCampos()
{
int iItems = 0;
foreach(System.Web.UI.WebControls.ListItem item in lstCampos.Items)
if (item.Selected)
iItems++;
string[] campos = new string[iItems];
int iPos = 0;
for(int i=0;i<lstCampos.Items.Count;i++)
if(lstCampos.Items[i].Selected)
{
campos[iPos] = lstCampos.Items[i].Text;
iPos++;
}
return
campos;
}
Creando el Reporte (Construyendo el RDL) en base al
XMLTextWriter
private void
generarRDL()
{
FileStream
stream;
stream = File.OpenWrite(Server.MapPath("/UIReport")+ "/DSIReport.rdl");
XmlTextWriter
writer = new XmlTextWriter(stream,
System.Text.Encoding.UTF8);
writer.Formatting = Formatting.Indented;
// Elementos del
Reporte
writer.WriteProcessingInstruction("xml", "version=\"1.0\"
encoding=\"utf-8\"");
writer.WriteStartElement("Report");
writer.WriteAttributeString("xmlns", null, "http://schemas.microsoft.com/sqlserver/reporting/2003/10/reportdefinition");
writer.WriteElementString("Width", "6in");
// Elementos del
DataSource
writer.WriteStartElement("DataSources");
writer.WriteStartElement("DataSource");
writer.WriteAttributeString("Name", null,
"DataSource1");
writer.WriteStartElement("ConnectionProperties");
writer.WriteElementString("DataProvider",
"SQL");
writer.WriteElementString("ConnectString", sConexion);
writer.WriteElementString("IntegratedSecurity",
"true");
writer.WriteEndElement(); // Cadena
de Conexion
writer.WriteEndElement(); // DataSource
writer.WriteEndElement(); // DataSources
// Escribiendo el Archivo
writer.Flush();
stream.Close();
}
Publicando el Reporte
Uno de los métodos que expone Reporting Service nos permite
hacer Upload del archivo RDL además de setear si el reporte va a ser sobrescrito, el nombre del
reporte, etc.
private void
uploadRDL()
{
ReportingService report = new
ReportingService();
report.Credentials = System.Net.CredentialCache.DefaultCredentials;
Byte[] definition = null;
Warning[] warnings = null;
string name =
"NUEVOREPORTE";
try
{
FileStream stream = File.OpenRead(Server.MapPath("/UIReport")+ "/DSIReport.rdl");
definition = new Byte[stream.Length];
stream.Read(definition,
0, (int) stream.Length);
stream.Close();
}
catch(IOException
e)
{
Console.WriteLine(e.Message);
}
try
{
warnings = report.CreateReport(name,
"/DemoReport", true,
definition, null);
if (warnings != null)
{
foreach
(Warning warning in
warnings)
{
Console.WriteLine(warning.Message);
}
}
else
Console.WriteLine("Report: {0} created successfully with no
warnings", name);
}
catch (SoapException
e)
{
Response.Write(e.Detail.InnerXml.ToString());
Response.End();
Console.WriteLine(e.Detail.InnerXml.ToString());
}
}
Conclusión
La particularidad del Reporting
Services nos da la facilidad de crear Interfaces que
usuario pueda elegir tanto los datos como el formato de los reportes. El RDL
nos da la alternativa de realizar eso mediante programación y el
Servicio Web de Reporting Service
nos expone varios métodos que podemos aprovechar no solo para generar
nuevos reportes sino a la vez de crear nuevos subscriptores para el reporte
generado entre cosas.
