Archivo del sitio

Configurar una red Multisitio con WordPress 3.0 sobre IIS 6 y MySQL.

Queremos configurar una red de blogs con WordPress.org y tenemos constancia de que su instalación nos va a resultar muy sencilla. Nos encontramos ante un ejemplo representativo de la tecnología LAMP. Programado en php, WordPress se comunica perfectamente con un sistema gestor de bases de datos MySQL mediante un servidor de aplicaciones Apache sobre un sistema operativo Linux. Bueno, bonito y barato…

Los problemas llegan cuando tenemos que adaptarnos al servidor que nos dan, y no es poco habitual que tenga las siguientes características. Sistema operativo Windows Server 2003 (tan obsoleto como presente en nuestras vidas), funcionando sobre el también anticuado Internet Information Server 6.0.

Vamos a ir instalando todas las utilidades necesarias paso a paso. Empezaremos por MySQL.

Instalación de MySQL en Windows Server 2003

Vamos a la web oficial de MySQL y descargamos la última versión gratuita disponible llamada MySQL Community Server . Yo he elegido el mirror de París.

Ejecutando este archivo el sistema nos muestra un asistente para la instalación del programa:

Aquí pulsamos “Next”, en la siguiente pantalla seleccionamos “Typical” volviendo a pulsar “Next” y en la siguiente (si no queremos modificar la ruta donde se va a instalar) pulsamos “Install”, esto provoca el comienzo de la instalación del programa, que una vez que termina muestra una pantalla donde tenemos que pulsar en “Finish”.

Una vez hecho esto, vamos a Inicio → Programas → MySQL → MySQL Server 4.1 → MySQL Server Instance Server Wizard (si es que no se ha abierto automáticamente).

En las sucesivas pantallas que se van mostrando al pulsar “Next” tenemos que seleccionar los siguientes datos (aunque siempre va a depender de nuestras propias necesidades):

  • En primer lugar marcaremos la opción Detailed Configuration y pulsaremos en “Next”, de esta forma podremos configurar más opciones de MySQL utilizando el asistente. Si marcásemos “Standard Configuration” el asistente nos pediría menos información pero habría que configurar algunas opciones manualmente.
  • Dependiendo del uso que queramos dar al equipo en el que se instala marcaremos una de las tres opciones:
    • Developer Machine: marcaremos esta opción si en el equipo donde hemos instalado MySQL Server se utiliza también para otras aplicaciones. MySQL Server utilizará la memoria mínima necesaria.
    • Server Machine: marcaremos esta opción si vamos a utilizar el equipo para algunas aplicaciones (no demasiadas). Con esta opción MySQL Server utilizará un nivel medio de memoria.
    • Dedicated MySQL Server Machine: marcaremos esta opción sólo si queremos utilizar el equipo como un servidor dedicado exclusivamente a MySQL. Con esta opción MySQL Server utilizará el máximo de memoria disponble. Se obtendrá un rendimiento elevado pero el equipo sólo servirá para MySQL. Yo he elegido esta última, ya que nuestro servidor va a estar dedicado exclusivamente a WordPress.
  • Dependiendo del uso que queramos dar a la Base de Datos marcaremos una de las tres opciones siguientes, normalmente se marcará Multifunctional Database salvo que queramos utilizar MySQL como base de datos para transacciones de otra Base de Datos MySQL.

  • Seleccionaremos la unidad y la carpeta donde queramos guardar los ficheros de datos (Tablespace)de la Base de Datos. A partir de la versión 4.0 de MySQL incorpora soporte para el control de la integridad referencial. A este nuevo tipo de tablas lo llama InnoBD.

  • Seleccionaremos ahora el número aproximado de conexiones concurrentes (varios clientes conectados a la vez) que tendra nuestro servidor de MySQL). La primera opción asume unas 20, la segunda unas 500 y la tercera permite especificarlas manualmente. Este parámetro es aproximado no tiene por qué ser exacto. Como pensamos crear una red multisite con bastantes blogs, la opción Online Transaction Processing puede ser la más adecuada.

  • Marcamos la casilla “Enable TCP/IP Networking”, establecer “Port Number” a 3306, marcar la casilla “Add firewall exception for this port” y marcar la casilla “Enable Strict Mode”.

  • Seleccionamos la opción “Best Support For Multilingualism” para establecer el encoding de la base de datos a UTF-8.

  • Marcamos las casillas “Install As Windows Service” e “Include Bin Directory in Windows PATH”, dejando el nombre del servicio por defecto.

  • Marcamos la casilla “Modify Security Settings”, estableciendo como usuario “root” y como contraseña “admin” (o la que queramos).

  • Pulsamos en “Execute” para que comience el proceso de configuración y cuando finalice podemos pulsar en “Finish”.

Tras la instalación podemos comprobar (si hemos seleccionado la opción de iniciar MySQL como servicio) que el servicio se está ejecutando. Esto se puede ver en el administrador de tareas.

Instalación de FastCGI para IIS 6.0

Ahora tenemos que conseguir que se ejecuten aplicaciones PHP sobre Windows Server 2003. Para ello nos descargaremos la extensión FastCGI, un protocolo estándar que permite que los archivos CGI ejecutables para entornos de aplicación interactúen con el servidor Web, ofreciendo rendimiento y estabilidad muy altos. Podemos instalarlo desde aquí.

Cuando se ejecuta el instalador FastCGI, se copian los archivos específicos de FastCGI en la carpeta “% windir % \ system32 \ inetsrv ” y, a continuación, se registra y habilita el servidor Web de extensión FastCGI. De los archivos que el programa de instalación copia, hay que tener en cuenta lo siguiente:

  • fcgiext.dll – Éste es el verdadero controlador de FastCGI que se comunica con los procesos habilitados FastCGI  para la tramitación de las solicitudes.
  • fcgiext.ini – Éste es el archivo de configuración que contiene la asignación de extensiones de archivos a los procesos FastCGI. También contiene la configuración de grupos de proceso FastCGI.
  • fcgiconfig.js – Esto configura la extensión FastCGI. La secuencia de comandos actualiza el archivo fcgiext.ini, modifica la metabase de IIS y recicla el grupo de aplicaciones del servicio Web si es necesario.

Descarga e instalación de PHP

Ahora nos disponemos a descargar el PHP. Nos descargamos el instalador desde el sitio oficial de PHP, después de instalar el FastCGI, este instalador se encarga del resto.

Nos descargamos el que dice “Non-thread-safe installer”, que es el adecuado para instalaciones sobre IIS. Es importante dirigirnos a donde dice Windows Binaries. Si lo bajamos de la página usual algunas cosas no funcionan bien. Por ejemplo, la librería php_curl.dll no funciona con los binarios genéricos.

Configurar la extensión FastCGI para trabajar con PHP

Para configurar manualmente la extensión y FastCGI de IIS, debemos crear asignaciones de scripts para la extensión de PHP en la metabase de IIS, y modificar el archivo fcgiext.ini que se encuentra en% windir % \ system32 \ inetsrv.

Para crear asignación de script:

  1. Ejecutamos inetmgr.exe.
  2. Hacemos doble clic en MiPC.
  3. Hacemos clic con el botón derecho en Mis sitios de red y hacemos clic en Propiedades.
  4. Vamos al directorio principal.
  5. Hacemos clic en configuración.
  6. Hacemos clic en Agregar.
  7. En el cuadro de diálogo Agregar o modificar asignación de extensión a aplicación hacemos clic en Examinar. Vamos al archivo fcgiext.dll que se encuentra en% windir % \system32\inetsrv.
  8. En la extensión del cuadro de texto, escribimos . php .
  9. En el cuadro de texto de la opción Limit to, escribimos GET, HEAD, POST .
  10. Habilitamos las opciones Script engine y Verify that the file exists.
  11. Hacemos clic en Aceptar .

Para modificar el archivo fcigext.ini:

Una vez que la asignación de script se ha añadido, modificamos el archivo fcgiext.ini.

  1. Agregamos una extensión de asignación de aplicación (php = PHP) a la sección [Tipos] .
  2. Añadir a la sección [PHP-ES] el ExePath = c: \ php \ php-cgi.exe (suponiendo que hemos instalado los archivos de PHP en la carpeta C: \ PHP).
  3. Después de guardar los cambios al archivo fcgiext.ini, reiniciamos el grupo de aplicaciones que está asociado con el sitio Web que aloja nuestras aplicaciones PHP.
[Types]
…
php=PHP
…
[PHP]
ExePath=c:\php\php-cgi.exe

Para configurar un documento predeterminado en IIS:

La mayoría de las aplicaciones PHP utilizan un archivo index.php, siendo este el fichero de solicitud por defecto. Configuraremos IIS para el tratamiento de este archivo como el contenido de la página por defecto.

  1. Lanzamos inetmgr.exe.
  2. Hacemos doble clic en el icono MiPC.
  3. Hacemos clic con el botón derecho en Mis sitios de red y hacemos clic en Propiedades.
  4. Hacemos clic en la pestaña Documentos.
  5. Hacemos clic en el botón Agregar.
  6. En el cuadro de diálogo Añadir contenido de página, en el cuadro de texto contenido de la página por defecto, escribimos index.php .
  7. Hacemos clic en Aceptar .

Establecer la configuración de FastCGI con óptima funcionalidad, seguridad y rendimiento con PHP

Para obtener la funcionalidad y rendimiento óptimos, configurar el servidor de la siguiente manera:

1. Modificar el php.ini archivo de la siguiente manera:

  • Establecemos fastcgi.impersonate = 1 . FastCGI bajo IIS admite la posibilidad de suplantar los tokens de seguridad del cliente que llama. Esto permite que IIS defina el contexto de seguridad bajo el cual la solicitud se ejecuta.
  • Establecemos cgi.fix_pathinfo = 1 . cgi.fix_pathinfo proporciona * real * PATH_INFO / support PATH_TRANSLATED para CGI. Anteriormente, el comportamiento de PHP era establecer PATH_TRANSLATED a SCRIPT_FILENAME, y no definir PATH_INFO. Para obtener más información sobre PATH_INFO, podemos consultar las especificaciones cgi. Al establecer este valor en 1, causamos que PHP CGI fije su ruta para que cumpla con la especificación.
  • Establecemos cgi.force_redirect = 0 .

2. Establecemos los parámetros de configuración FastCGI para la sección de PHP ejecutando fcgiconfig.js de la siguiente manera:

  • Establecer el proceso FastCGI propiedad piscina InstanceMaxRequests a 10.000 . Esta configuración especifica que la extensión FastCGI reciclará php-cgi.exe después de que ha tramitado 10.000 solicitudes de éxito.

cscript> fcgiconfig.js-set-sección: "PHP"-InstanceMaxRequests: 10000
3. Configuramos la extensión FastCGI para establecer las variables de entorno PHP_FCGI_MAX_REQUESTS para el proceso de PHP a 10 mil . Este valor indica a PHP-cgi.exe que se recicle después de haber tramitado 10.000 solicitudes de éxito.

fcgiconfig.js cscript>-set-sección: "PHP"-EnvironmentVars: PHP_FCGI_MAX_REQUESTS: 10000

Nota: Podemos configurar InstanceMaxRequests y PHP_FCGI_MAX_REQUESTS para que utilicen otros números en vez de 10000. Como regla general, nos aseguraremos de que el valor de InstanceMaxRequests es menor o igual al valor de PHP_FCGI_MAX_REQUESTS .

Prueba de PHP CGI

Después de instalar la extensión FastCGI y el registro y la configuración del CGI PHP, deberíamos poder solicitar nuestra aplicación PHP y comprobar que funciona.

Para probar la aplicación PHP, creamos y solicitamos una página phpinfo.php en el sitio que contiene lo siguiente:

<? php phpinfo (); ?>

Instalación de WordPress.

Llegados a este punto la instalación es muy sencilla.

En resumen lo que hay que hacer para instalarlo en IIS 6 es lo siguiente:

1. Creamos una base de datos en nuestro servidor de MySQL. Le ponemos el nombre que queramos. Creamos un usuario con acceso para crear y modificar datos y tablas.

2. Descomprimimos nuestra descarga de WordPress  y colocamos este fichero en nuestro directorio de publicación de IIS, tal como publicaríamos cualquier otro contenido. Ponemos un nombre  a la carpeta que será nuestra URL.

3. Abrimos nuestra consola de administración de IIS y nos creamos una nueva Application Pool. Por ejemplo, le ponemos de nombre PHP y dejamos los defaults. Ahora vamos al sitio web de nuestro WordPress, hacemos clic con el botón derecho, hacemos clic en propiedades y la convertimos como aplicación seleccionando la Application Pool que acabamos de hacer.



4. Revisamos la raíz de esta carpeta y le damos permiso al usuario IUSR_TUMAQUINA de escritura en la misma. Cuando acabemos le quitaremos este permiso.

5. Finalmente navegamos a nuestro sitio raíz y le decimos que queremos crear un archivo de configuración. Simplemente llenamos los formularios que el instalador de WordPress nos presenta.

Habilitar WordPress Multisite.

Realmente WordPress le llama a esto una red de sitios. Puede ser por dominio o por directorios. Como incluimos esta instalación en un directorio, sólo podemos usar subdirectorios.

Lo único que tenemos que hacer es abrir nuestro wp-config.php y agregar esta línea justo arriba de donde dice:

1
2
/* That's all, stop editing! Happy blogging. */
define('WP_ALLOW_MULTISITE', true);

Esto va habilitar la funcionalidad de Red. Ahora si vamos a nuestro Dashboard, veremos una nueva opción en el menú Administration > Tools llamada Network.

Le ponemos un nombre a nuestra red y continuamos. Nos aparecerá una pantalla en la que debemos realizar lo siguiente:

  1. Creamos un directorio llamado blogs.dir en nuestro directorio wp-content y damos permiso de escritura al usuario IUSR_TUMAQUINA.
  2. La segunda consiste en agregar estas líneas a nuestro wp-config.php. 
  3. Y ahora llega lo más engorroso. Si estuviéramos en IIS 7 con el módulo URL Rewrite nuestro WordPress nos pondría unas líneas para modificar el archivo web.config para que el IIS 7 hiciera las redirecciones. Pero como ya sabemos no es el caso. Tenemos que conformarnos con el IIS 6 así que WordPress nos pone las instrucciones de redirección como lo haría con Apache. Vamos a solucionar esto.

URL Rewrite con IIS 6

Vamos a utilizar un software gratuito llamado Ionic’s Isapi Rewrite Filter, que nos permitirá escribir un fichero .htaccess que IIS reconocerá tal y como lo haría Apache.

Vemos a continuación los pasos de instalación.

  1. Iniciamos el instalador.
  2. Aceptamos la licencia y seleccionamos instalar todo.
  3. Seleccionamos en cuál de nuestros sitios Web queremos colocar el filtro IIRF (es una librería IIRF.dll).
  4. Hacemos clic en instalar para que comience a instalar el software.

Lo que hace es copiar varios archivos a nuestro disco, darle permiso al grupo IIS_WPG para leer y colocar su librería IIRF.dll como filtro en el WebSite que le indicamos.

Los ficheros los coloca aquí.

El importante es el IIRF.dll del que ya habíamos hablado y el otro es el IirfGlobal.ini que se encarga de instrucciones globales como lanzar el Rewrite Engine o colocar el archivo de logs.

En cualquier caso, nosotros vamos a poner las instrucciones de redirección de forma local en nuestro directorio. Para eso lo convertimos en aplicación de IIS.

Ahora ya sólo queda poner las reglas que nos dijo WordPress, aunque no son exactamente iguales. Éstas son las reglas tal y como deben quedar para nuestra carpeta.

RewriteEngine On
# Redirecciona a la correcta pagina inicial del subsitio
RedirectRule ^([_0-9a-zA-Z-]+)$ $1/ [I]
RewriteRule ^index\.php$ - [L]
# uploaded files
RewriteRule ^([_0-9a-zA-Z-]+/)?files/(.+)(\?.*)$ wp-includes/ms-files.php?file=$2 [L]
RewriteRule ^([_0-9a-zA-Z-]+/)?files/(.+) wp-includes/ms-files.php?file=$2 [L]
# add a trailing slash to /wp-admin
RewriteRule ^([_0-9a-zA-Z-]+/)?wp-admin$ $1wp-admin/ [R=301,L]
RewriteCond %{REQUEST_FILENAME} -f [OR]
RewriteCond %{REQUEST_FILENAME} -d
RewriteRule ^ - [L]
RewriteRule ^([_0-9a-zA-Z-]+/)?(wp-(content|admin|includes|login).*) $2 [L]
RewriteRule ^([_0-9a-zA-Z-]+/)?(.*\.php)$ $2 [L]
RewriteRule ^([_0-9a-zA-Z-]+/)?(.*attachment_id=.*)$ $2 [L]
RewriteRule ^([_0-9a-zA-Z-]+/)?(\?.*)$ $2 [L]

RewriteRule . index.php [L]

Y así hemos llegado al fin de la instalación de la red multisitio de WordPress en estas peculiares condiciones. Con este mismo escenario se ha creado la red de blogs de la nueva página web de la Universidad Cardenal Herrera – CEU.
Éste es uno de los blogs de la red multisite. Blog de Sala Prensa

Un saludo.

Agradecimientos a: Guillermo Humberto Vera Amaro y Ruslan Yakushev

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.

Desarrollar un portal a medida o usar un CMS prefabricado

Cuando una persona o empresa tiene la necesidad de hacer un portal en internet encontrara proveedores que ofrecen dos tipos de soluciones. La primera, basada en eldesarrollo del portal desde cero, es decir, a la medida; y otra, usando CMS (Manejadores de contenidos prehechos) como Joomla, Drupal, Liferay o WordPress (estos dos últimos probados personalmente), entre otros. Existen muchísimos escenarios y la solución dependerá de la necesidad que presenta. A continuación comentaremos qué ventajas tiene una solución en cuanto a la otra y cuando es mejor hacer uso de alguna de las 2 opciones presentadas.

Un CMS es un sistema prefabricado que con solo minutos se puede publicar un sitio en internet con un costo mínimo o totalmente gratis. Aunque también dan lugar a desarrollos complejos si se desea y se dispone de recursos y presupuesto para test.

Ventajas de los CMS:

  • Rápida Implementación: existen miles de desarrolladores aportando a una comunidad, prefabricando módulos que pueden ser adaptados a cualquier portal que use el CMS. Los Widgets ( WordPress) y los Portlets (Liferay), son realmente fáciles de usar.
  • Bajos Costos: Debido a que la mayoría de los módulos están realizados, los tiempos de adaptación son bajos y por ende los costos también.
  • Esto no impide que puedas acceder a los CSS y al código php, así como gestionar tu base de datos MySQL a través de Apache o de IIS, si trabajamos con wordpress.org. Liferay permite usar Hibernate para acceder a bases de datos (DB2, HSQLDB, MySQL, Oracle, PostgreSQL…) a través de servidores JBoss, Tomcat, Glassfish, etc, así como el uso de JSF, Struts, Facelets…

Desventajas de los CMS:

  • Seguridad: así como existen comunidades desarrollando para estas plataformas existen comunidades dedicadas a encontrar vulnerabilidades de tal manera que al encontrar una,  nos damos cuenta que muchos portales que usan el CMS no están en línea. WordPress ha sufrido algunas reconocidas públicamente estos últimos días.
  • Extensibilidad: Cualquier funcionalidad que se requiera a la medida porque no existe en la comunidad es mucho más difícil de integrar ya que el desarrollo debe ser adaptado al CMS y pasa muchas veces que la plataforma impide dicha adaptación.
  • Performance: Los CMS son plataformas muy genéricas que tratan de adaptarse a todas las necesidades, por ser tan genérico las consultas a las base de datos y el procesamiento que estas plataformas hacen son muchas, por lo tanto a medida que la plataforma tenga más datos la plataforma se va poniendo cada vez mucho más lenta.

En fin, si su necesidad es básica y la necesita lo más pronto posible es muy buena opción usar cualquiera de los más populares CMS.

Desarrollo a medida

Un portal a la medida es un sistema hecho desde cero 100% a las necesidades del cliente.

Ventajas de un desarrollo a medida:

  • Extensibilidad: al tener control en un 100% del código fuente del software y tener una arquitectura a la medida cualquier funcionalidad puede ser desarrollada sin ningún problema.
  • Seguridad: Todos los parámetros de seguridad en el software pueden ser configurados sin ningún problema y se puede programar cualquier funcionalidad para prevenir ataques.
  • Performance: Las consultas a la base de datos y el código realizado por estar hecho a la medida solo se usa lo necesario, por lo tanto solo se ejecuta lo que se necesita haciendo que el sitio sea más rápido.
  • Alto nivel de personalización: cualquier adaptación a nivel del diseño, programación, SEO y cualquier elemento que esté dentro del software puede ser personalizado sin ningún problema.
  • Evolución con la empresa: a medida que la empresa evoluciona el software puede evolucionar junto a la empresa.
  • No hay límites: cualquier necesidad tecnológica puede ser adaptada sin ninguna restricción.
  • Integraciones: si se quiere que el software se integre con data de otra aplicación no hay ningún problema. Si se quiere compartir la data de la aplicación con un tercero se pueden desarrollar todos los mecanismos seguros de integración.

Desventajas de un desarrollo a medida:

  • Tiempos: por ser hecho todo desde 0, los tiempos son mucho más largos.
  • Costos: por la misma razón de que los tiempos de desarrollo son más largo y se necesita personal capacitado para el desarrollo, los costos también son más altos.

En fin, si necesitan una solución que tenga que ir creciendo a medida que evolucione su empresa, el desarrollo a la medida es su mejor opción. Si necesita que su aplicación sea segura y que nadie acceda a información privada cerciórese de que su aplicación sea segura y confiable.

Fuente: http://www.readwriteweb.es/

A %d blogueros les gusta esto: