Importar contenidos a WordPress a partir de un RSS implementado en ASP.NET

Este post pretende dar una idea de las posibilidades de los sistemas RSS para guardar y recuperar toda la información contenida en una página web, un blog, o simplemente en una base de datos.

Es ya muy conocida la utilidad de esta tecnología para recibir información de interés, mediante los lectores RSS, previa suscripción a un canal, sin necesidad de visitar una a una las páginas web de las que deseas obtener dicha información.

Pues bien, WordPress.org incorpora la posibilidad de importar un fichero RSS, de tal manera que toda la información contenida en ese fichero será reconocida. Como el RSS tiene un formato XML estándar, hay garantías de que no se perderá información durante el camino.

Si tenemos la información en otro blog o página web, sólo debemos exportar el fichero con el código fuente del feed e importarlo directamente en WordPress.org. La mayoría de las páginas web cuentan hoy día con la posibilidad de obtener un feed de manera muy sencilla. Generalmente sólo hay que hacer click a un icono, generalmente con este aspecto:

La importación a WordPress.org es igualmente sencilla desde el panel de administrador de nuestro blog. En la parte izquierda, hacemos click en el menú desplegable Herramientas y podremos ver la opción Importar. Si al enlazar dicha opción no vemos la opción RSS, podemos instalar cualquiera de los plugins que se nos ofrece. Aquí teneís el más famoso: http://wordpress.org/extend/plugins/rss-import/

Si sois expertos en código php + WordPress o queréis adentraros en ese mundo, podéis intentar conseguir la importación del RSS sin plugins siguiendo este tutorial (está en inglés): http://perishablepress.com/press/2009/04/26/import-and-display-rss-feeds-in-wordpress/

Estructura de un RSS

<?xml version="1.0" encoding="ISO-8859-1" ?>
<rss version="2.0">
<channel>
<title>WebNet Architect</title>
<link>https://webnetarchitect.wordpress.com</link&gt;
<description>Tutorial para importar RSS mediante ASP.NET</description>
<item>
<title>Estructura de un RSS</title>
<link>http://wp.me/p1w1Ur-6G</link>
<description>Ejemplo de la estructura de un RSS básico</description>
</item>
</channel>
</rss>

La primera línea del documento es la declaración de XML que define la versión XML y la codificación de caracteres utilizados en el documento. En este caso, el documento se ajusta a la 1.0 especificación de XML y utiliza el conjunto de caracteres utf-8 .
La siguiente línea es la declaración RSS, que identifica que trata, de hecho, un documento RSS (más concretamente, RSS versión 2.0).

La siguiente línea contiene el elemento <channel> . Este elemento se utiliza para describir la fuente RSS. El elemento <channel> define tres elementos requeridos:

  • <title> : define el título del canal (por ejemplo, el nombre de su sitio Web)
  • <link> : define el hipervínculo al canal (por ejemplo, https://webnetarchitect.wordpress.com)
  • <description> : describe el canal (por ejemplo Tutorial para importar…)

Cada elemento de <channel> puede tener uno o más elementos de <item> . Cada elemento de <item> define un artículo dentro de la RSS feed.

El elemento <item> requiere tres elementos secundarios:

  • <title> : define el título del tema (por ejemplo, primer artículo)
  • <link> : define el hipervínculo al elemento (por ejemplo, http://wp.me/p1w1Ur-6G)
  • <description> – describe el elemento (por ejemplo, la descripción del primer artículo)

Primer paso: Comprobar tipos de datos en la tabla correspondiente de la base de datos.

En este ejemplo vamos a trabajar con la base de datos del Docu de la Universidad Cardenal Herrera CEU. Al trabajar con ASP.NET, lo normal es que las noticias se almacenen en la base de datos de Microsoft SQL Server. En nuestro caso, los artículos se almacenan en una tabla denominada DOCU_NOTICIA, que contiene los campos siguientes:

  • DNOT_Id : un campo de número entero de clave principal de incremento automático identificar de forma única cada artículo
  • DNOT_Titulo : un nvarchar(256), especifica el título del artículo.
  • DNOT_Autor : un nvarchar(50), especifica al autor del artículo.
  • DNOT_Cabecera : un nvarchar(500), proporcionando una descripción más detallada del artículo.
  • DNOT_Categoría: nvarchar(50), especifica la categoría del artículo.
  • DNOT_Texto: un ntext con el texto de la noticia.
  • DNOT_Imagen: un nvarchar(50), especifica la url de la imagen alojada en el servidor.
  • DNOT_Fecha – un datetime, indicando la fecha que publicó el artículo.

Nos hemos dejado otros campos de la tabla, pero los mencionados son los únicos que estamos interesados para utilizar en nuestro feed.

Segundo paso: Creación de un procedimiento almacenado para consultas a la tabla.

 Si no existe ya el procedimiento almacenado que realice las consultas a los campos de la tabla que necesitamos para generar nuestro RSS, tenemos que crearlo.

Para ello recomiendo instalar el SQL Server Management Studio Express 2008, que se puede descargar aquí.

 Para crear el procedimiento almacenado sp_obtener_DOCU_NOTICIA_todosRSS escribimos el siguiente código:

CREATE PROCEDURE [dbo].[sp_obtener_DOCU_NOTICIA_todosRSS]
AS
SET TRANSACTION ISOLATION LEVEL READ COMMITTED
SELECT
[DNOT_Id] as [id],
[DNOT_Titulo] as [title],
[DNOT_Cabecera] as [header],
[DNOT_Texto] as [description],
[DNOT_Fecha] as [pubDate],
[DNOT_Categoria] as [category],
[DNOT_Imagen] as [image],
[DNOT_Autor] as [author]
FROM
[dbo].[DOCU_NOTICIA]
ORDER BY [DNOT_Fecha] DESC


Tercer paso: Creación de un ConnectionString en el web.config

En nuestro proyecto en ASP.NET depositamos la información de configuración de todos nuestros proyectos, incluidos los parámetros de conexión con nuestra base de datos, en una clase llamada Conexiones. Al guardar la información de la cadena de conexión, vamos a evitar tener que codificar en el archivo de código subyacente. Esto simplifica las cosas, si cambia la información de la cadena de conexión en el futuro. El método de esa clase que contiene la información es en concreto el siguiente (oculto id de usuario y contraseña por razones obvias):

public static System.Data.SqlClient.SqlConnection Conectar()
{
SqlConnection sqlConn = new SqlConnection();
sqlConn.ConnectionString = "Server=webnet;Database=WEB;" +
"User ID=******;Password=******;" +
"Trusted_Connection=False";
return sqlConn;
}

Cuarto paso: Creación de una página rss.aspx

 El siguiente paso es crear una página Web en ASP.NET (rss.aspx) que mostrará una lista de las noticias más recientes como un documento con formato correcto de RSS 2.0. En el Solution Explorer, hay que hacer clic en el nombre del proyecto y, a continuación, hacer clic en Add New Item. Posteriormente en el cuadro de diálogo templates, hay que hacer clic en Web Form.

En el cuadro Name , escribimos un nombre para la nueva página Web (rss.aspx) y, a continuación, hacmos clic en Add.

Lo primero que debemos hacer en la página es quitar todos los controles de marcado o web HTML  y, a continuación, establecer la propiedad ContentType de la directiva @pagetext/xml“.

Después de borrar todo el marcado HTML, agregamos el nombre del método que programaremos posteriormente en el fichero rss.aspx.cs que también se ha creado. Éste es es aspecto de la página rss.aspx , después de haber hecho algunos cambios:

<%@ Page Language="C#" ContentType="text/xml" AutoEventWireup="true" CodeBehind="rss.aspx.cs" Inherits="rss" %>
<% = obtenerNoticiaRSS() %>

En el fichero rss.aspx.cs implementamos en C# el método que hemos invocado en el formulario. En primer lugar debemos recuperar los datos de la base de datos, llamando al procedimiento almacenado que hemos creado anteriormente. Éste es el código que abre la conexión a la base de datos e introduce los datos en un contenedor de datos.
public static void obtenerNoticiaRSS()
{

Llamamos aquí al método Conectar de la clase Conexiones que hemos visto antes.

SqlConnection connWebceuWeb = Conexiones.Conectar();

El fichero se guardará en la carpeta RssDocu y en la subcarpeta de la fecha actual.

String fechaDir = DateTime.Now.Day.ToString() + "_" + DateTime.Now.Month.ToString() + "_" + DateTime.Now.Year.ToString();
String path = @"C:\temp\";
DirectoryInfo di = Directory.CreateDirectory(path + @"\RssDocu\" + fechaDir);
String ruta = path + @"\RssDocu\" + fechaDir;
FileInfo fichero = new FileInfo(ruta + @"\" + "RssDocu.xml");
StreamWriter sr = fichero.CreateText();
try
{
SqlCommand cmdObtenerNoticias = new SqlCommand();
cmdObtenerNoticias = new System.Data.SqlClient.SqlCommand();
cmdObtenerNoticias.CommandText = "dbo.[sp_obtener_DOCU_NOTICIA_todosRSS]";
cmdObtenerNoticias.CommandType = System.Data.CommandType.StoredProcedure;
cmdObtenerNoticias.Connection = connWebceuWeb;
SqlDataAdapter da = new SqlDataAdapter();
if (connWebceuWeb.State == ConnectionState.Closed) {
connWebceuWeb.Open();
}
da.SelectCommand = new SqlCommand();
da.SelectCommand = cmdObtenerNoticias;
DataSet ds = new DataSet();
da.Fill(ds);
DataView dv = ds.Tables[0].DefaultView;

A continuación hay que incluir el código que nos muestre el contenido de las etiquetas que forman la estructura xml del RSS. Además de mostrarlo en el formulario lo guardaremos en un fichero de texto, que será el que podremos importar posteriormente. Utilizaremos un objeto de C# StreamWriter, que hemos instanciado previamente llamándolo sr.
sr.Write("<?xml version=\"1.0\" encoding=\"utf-8\"?>");
sr.Write("<rss version=\"2.0\" xmlns:blogChannel=\"http://www.uchceu.es\" ");

Añadimos todos los espacios de nombres que consideramos interesantes.
sr.Write("xmlns:content=\"http://purl.org/rss/1.0/modules/content/\"\n");
sr.Write("xmlns:wfw=\"http://wellformedweb.org/CommentAPI/\"\n");
sr.Write("xmlns:dc=\"http://purl.org/dc/elements/1.1/\"\n");
sr.Write("xmlns:atom=\"http://www.w3.org/2005/Atom\"\n");
sr.Write("xmlns:sy=\"http://purl.org/rss/1.0/modules/syndication/\"\n");
sr.Write("xmlns:slash=\"http://purl.org/rss/1.0/modules/slash/\">\n");
sr.Write("<channel>\n");
sr.Write("<title>Docu. La revista de la Universidad CEU Cardenal Herrera.</title>\n");

El espacio de nombres atom:link incluye el link a la página del rss
sr.Write("<atom:link href=\"http://blog.uchceu.es/docu/rss.aspx\" rel=\"self\" type=\"application/rss+xml\" />\n");
sr.Write("<link>http://www.uch.ceu.es/principal/docu</link&gt;\n");
sr.Write("<description>");
sr.Write("Este RSS sirve para suscribirse a las noticias del DOCU de la Universidad CEU Cardenal Herrera.");
sr.Write("</description>\n");

La etiqueta LastBuildLate sirve para ver si se puede incluir dinámicamente, pero en este caso la hemos dejado vacía.
sr.Write("<lastBuildLate>");
sr.Write("");
sr.Write("</lastBuildLate>\n");

Indicamos lengua en que está escrita la información.
sr.Write("<language>");
sr.Write("es");
sr.Write("</language>\n");

Añadimos modulo “syndication”.
sr.Write("<sy:updatePeriod>");
sr.Write("hourly");
sr.Write("</sy:updatePeriod>\n");
sr.Write("<sy:updateFrequency>");
sr.Write("1");
sr.Write("</sy:updateFrequency>\n");

También el módulo generador.
sr.Write("<generator>");
sr.Write("http://wordpress.org/?v=3.1");
sr.Write("</generator>\n");

Abrimos un bucle que recorre la tabla.
for (int i = 0; i < dv.Table.Rows.Count; i++)
{
sr.Write("<item>\n");
sr.Write("<title><![CDATA[ ");
string tituloNot = dv.Table.Rows[i]["title"].ToString();
tituloNot = tituloNot.Replace("<b>", "");
tituloNot = tituloNot.Replace("</b>", "");
sr.Write(tituloNot);
sr.Write("]]></title>\n");

A continuación escribimos la etiqueta <link> pero la dejamos vacía porque no podemos clasificar segun el id de las noticias, ya que las va a clasificar wordpress según sus algoritmos.
sr.Write("<link>");
sr.Write("</link>\n");

Añadimos la fecha de publicacion, la convertimos a string, y obtenemos subcadenas para obtener día, més y año. También podríamos haber recurrido a métodos del objeto string.
DateTime fecha = DateTime.Parse(dv.Table.Rows[i]["pubdate"].ToString()).
string strDia = fecha.Date.DayOfWeek.ToString();
strDia = strDia.Substring(0, 3);
string strMes = devolverMes(fecha.Month);
string strFecha = strDia + ", " + fecha.Date.Day.ToString() + " " + strMes + " " + fecha.Date.Year.ToString() + " " +   fecha.Date.TimeOfDay.ToString() + " GMT";
sr.Write("<pubDate>" + strFecha + "</pubDate>\n");

Añadimos el autor  mediante el espacio de nombres de Dublin Core.
sr.Write("<dc:creator><![CDATA[");
if (dv.Table.Rows[i]["author"].ToString() != "")
sr.Write(dv.Table.Rows[i]["author"].ToString());
else sr.Write("Administrador");
sr.Write("]]></dc:creator>\n");
sr.Write("<category>");
sr.Write(dv.Table.Rows[i]["category"].ToString());
sr.Write("</category>\n");

De nuevo, ponemos <guid> en blanco porque no podemos clasificar segun el id
sr.Write("<guid isPermaLink=\"false\">");
sr.Write("");
sr.Write("</guid>\n");

Añadimos el texto de las noticias.
sr.Write("<description>");
sr.Write(dv.Table.Rows[i]["header"].ToString() + "\n");
sr.Write("</description>\n");

Añadimos la etiqueta content:encoded,que incluye las imágenes y los vídeos. Es importante reemplazar algunos caracteres que influirán negativamente en la visión de la noticia importada.
string cabecera = dv.Table.Rows[i]["header"].ToString();
cabecera = cabecera.Replace("  ", "");
cabecera = cabecera.Replace("\n", "");
cabecera = cabecera.Replace("\r", "");
string descripcion = dv.Table.Rows[i]["description"].ToString();
descripcion = descripcion.Replace("\n", "");
descripcion = descripcion.Replace("\r", "");
sr.Write("<content:encoded>");
sr.Write("<![CDATA[");
if (dv.Table.Rows[i]["image"].ToString() != "")
{

En nuestra base de datos se han colado etiquetas innecesarias. por ejemplo la eqtiqueta <b> de los alt de las imagenes. Si os ocurre algo similar en vuestras bases de datos, tendréis que reemplazarlos como hacemos aquí.
string titulo = dv.Table.Rows[i]["imageTitle"].ToString();
titulo = titulo.Replace("<b>", "");
titulo = titulo.Replace("</b>", "");

Es muy importante cambiar las rutas de las imagenes si las vamos a subir al servidor de WordPress.
string urlImagen = dv.Table.Rows[i]["image"].ToString();
urlImagen = urlImagen.Replace("archivos_subidos/imagenes/", "/wp-content/uploads/docu/");
sr.Write(cabecera);
sr.Write("<p><img alt='" + titulo + "' src='" + urlImagen + "'/></p>");
sr.Write("<p>" + dv.Table.Rows[i]["imageDesc"].ToString()  + "</p>");
sr.Write(descripcion);
sr.Write("]]></content:encoded>\n");
}
else
{
sr.Write(cabecera);
sr.Write(descripcion);
sr.Write("]]></content:encoded>\n");  }
if (dv.Table.Rows[i]["file"].ToString() != "")
{
sr.Write("http://blog.uchceu.es/wp-content/uploads/docu/" + dv.Table.Rows[i]["file"].ToString();
}
sr.Write("</item>\n");
}
sr.Write("</channel>\n");
sr.Write("</rss>\n");
}
catch (Exception ex)
{
Utilidades.Utilidades.mandarMail("desarrolloweb@uch.ceu.es", "anonimo@uch.ceu.es", "No se puede escribir RSS : " + ruta, ex.Message);
}
finally
{
if (connWebceuWeb.State == ConnectionState.Open)
{
connWebceuWeb.Close();
}
if (sr != null)
{
sr.Close();
}
}
}

Resultados:

Este ejemplo pertenece al Docu de la Universidad Cardenal Herrera CEU. Tras aplicar el código para importar el RSS en la plataforma WordPress que creamos y diseñarlo a nuestro gusto se han obtenido los resultados que podéis ver en la Página del Docu.

También se ha aplicado el mismo método para importar el contenido de la página SalaPrensa, y próximamente se aplicará a todos los blogs antiguos de la Universidad Cardenal Herrera CEU.

Un saludo.

Publicado el 31 mayo, 2011 en Prácticas con Web y etiquetado en , , , , . Guarda el enlace permanente. Deja un comentario.

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s

A %d blogueros les gusta esto: