Publicando RSS com ASP.NET RSS Toolkit - Parte 2

Olá, Caros leitores.

No último artigo, aprendemos os princípios básicos que norteiam o padrão RSS, tão popular entre sites e blogs atuais, um pouco do histórico da tecnologia e estrutura interna de um feed RSS. Logo, estamos mais que prontos para iniciara contrução de nosso próprio Feed, publicá-lo e consumi-lo usando o Visual Studio 2008.

Para este artigo, estamos utilizando o componente open source ASP.NET RSS Toolkit disponível no repositório para .NET Framework conhecido como Codeplex e disponível neste endereço. Ele permite tanto facilitar a criação de RSS em seu website, quanto ferramentas para exposição de conteúdo de feeds, agilizando assim o processo de desenvolvimento, bem como torna fácil a transformação em RSS de conteúdos de diversos tipos e origens, sem necessariamente se criar uma base de dados para tal fim.

1. Instalação

Primeiramente, faça o download do RSS Toolkit e descompacte o conteúdo do arquivo em uma pasta. Dentro dela deve estar um arquivo RssToolkit.dll, é dele que iremos precisar.Crie um novo projeto web (Web Site ou Web Application, embora este último seja o mais recomendado devido a sua característica de compilar os arquivos de código em uma dll) e copie o RssToolkit.dll para dentro da pasta bin de seu site. Referencie o objeto a partir do VS 2008, o que pode ser feito com um simples clique no botão refresh do solution Explorer, caso seu projeto seja do tipo Web Site, ou clicando com o botão direito do mouse em References, selecionando a opção addReference e selecionando a dll através da aba Browse, caso o projeto utilizado seja do tipo Web application. Pronto, a nossa biblioteca de RSS, já fora instalada.

2. Implementação do Feed

Agora, adicione um nova página aspx, através do menu Project>Add New Item e selecione um item do tipo Web Form, e coloque o nome de “rss.aspx”. Com a página aberta na tela pressione F7 para ver o Code Behind do documento e adicione as linhas abaixo:

using RssToolkit.Rss;
using System.Xml;
using System.Collections.Generic;
 
namespace rss
{
    public partial class rss : System.Web.UI.Page
    {
        protected void Page_Load(object sender, EventArgs e)
        {
            //inicializando o RSS
            RssDocument RSSdoc = new RssDocument();            
            RssChannel canal = new RssChannel();
            canal.PubDate = System.DateTime.Now.ToString();
            canal.Description = "Posts sobre desenvolvimento de software e banco de dados";
            canal.Title = "Canal de Desenvolvimento Café com Bits";
            canal.Link = "rss.aspx";
            RSSdoc.Channel = canal;
            RSSdoc.Version = "2.0";
 
            RSSdoc.Channel.Items = new List<RssItem>();
 
            //preenchendo items
            DataSet ds = new DataSet();
            ds.ReadXml(Server.MapPath("datateste.xml"));
            for (int i = 0; i < ds.Tables[0].Rows.Count; i++)
            {
                RssItem item = new RssItem();
                item.Title = ds.Tables[0].Rows[i]["titulo"].ToString();
                item.Description = ds.Tables[0].Rows[i]["resumo"].ToString();
                item.Link = ds.Tables[0].Rows[i]["url"].ToString();                
                RSSdoc.Channel.Items.Add(item);
            }
 
            //criando stream
            string outPutRSS = RSSdoc.ToXml(DocumentType.Rss);
            XmlDocument doc = new XmlDocument();
            doc.LoadXml(outPutRSS);
            Response.ContentType = "text/xml";
            doc.Save(Response.OutputStream);
            Response.End();
        }
    }
}

Agora verificando um pouco o código, percebe-se que mesmo as classes utilizadas não fogem muito da estrutura hierárquica que aprendemos constituir o RSS. A classe RssDocument representa o elemento container do código RSS, ou a tag <RSS></RSS> numa comparação com um feed RSS comum, possuindo ainda as mesmas propriedades constituintes Channel e Version.

A classe RssChannel, da mesma forma, encapsula a estrutura interna da tag <Channel></Channel> e suas propriedades PubDate, Title, Description e Link e a coleção de notícias atualizáveis, representado pelo atributo Items.

Items utiliza a coleção de lista generics List<>, disponível através da inclusão da biblioteca System.Collections.Generics para ordenar objetos do tipo RssItem, que por sua vez armazenam as informações relativas a cada noticia publicada.

Agora analisemos mais um pouco as linhas de código listadas abaixo:

DataSet ds = new DataSet();
            ds.ReadXml(Server.MapPath("datateste.xml"));
            for (int i = 0; i < ds.Tables[0].Rows.Count; i++)
            {
                RssItem item = new RssItem();
                item.Title = ds.Tables[0].Rows[i]["titulo"].ToString();
                item.Description = ds.Tables[0].Rows[i]["resumo"].ToString();
                item.Link = ds.Tables[0].Rows[i]["url"].ToString();                
                RSSdoc.Channel.Items.Add(item);
            }
 

Temos um elemento DataSet, sendo preenchido com dados oriundos de uma fonte de dados qualquer (no nosso caso, um arquivo XML) e que percorrendo as linhas das tabelas constituintes do DataSet possibilitamos a inclusão de cada novo item na nossa lista.

A grande vantagem desse tipo de abordagem é que tornamos o processo de criação de feeds bastante geral e amplamente adaptável para qualquer tipo de tabela que necessitarmos, desde que tais dados possam satisfazer as propriedades do RSSItem e sem restrição com relação a fonte de dados utilizada para tanto, desde um simples arquivo XML até uma fonte de dados ODBC, um arquivo em Access ou baseada no cliente nativo do SQL Server ou de outros BDs.

Dando prosseguimento a nossa análise, percebemos outra vantagem da classe RssDocument. A classe gera toda a estrutura interna que acabamos de montar na linguagem XML e aplicando ainda o tipo de formatação específica para o formato de RSS a ser utilizado pelo desenvolvedor (a saber, RSS, ATOM, RDF, OPML e Unknow que representa um modelo que pode ser personalizado). Armazenamos então o retorno do métdo ToXml() na string outputRSS.

string outPutRSS = RSSdoc.ToXml(DocumentType.Rss);

Esse conteúdo será por fim carregado pela classe XmlDocument da biblioteca System.Xml e liberado para o usuário como Stream.

Para ver o resultado, sete a página como rss.aspx como inicial, clicando sobre o ícone que a representa no Solution Explorer e selecionando a opção “Set as Start Page” e pressione F5. O seu navegador deve exibir uma página contendo a estrutura do XML formado semelhante à mostrada abaixo.

3. Publicando o Feed

Com o nosso feed pronto, iremos fazer uma página agora para consumi-lo. Para este exemplo, vamos utilizar da página Default.aspx gerada automática mente quando criamos nosso projeto.

Siga até a Toolbar, clique com o botão direito do mouse em qualquer área disponível abaixo das barras de ferramentas comuns ao VS 2008 e selecione Add Tab e ponha o nome de “RSS Toolkit”, em seguida clique novamente com o botão direito em qualquer área em branco disponível para aba que acabou de criar e selecione a opção Choose Items, siga até a pasta Bin onde colocamos o RssToolkit.dll e selecione-o, clicando ok em seguida. Repare que a Toolbar fora preenchida com dois novos componentes, o RssHyperlink e o RssDataSource. Selecione o primeiro e arraste até uma área desejada na página Default.aspx.

O RssHyperLink estende o componente nativo HyperLink do .NET e possui um recurso importante que é o fato de que cada componente desse tipo colocado na página, além da função básica que lhe é destinada, ou seja, servir de meio de locomoção entre páginas, cria em tempo de execução tags HTML no seguinte formato:

<link rel="alternate" type="application/rss+xml" title="Teste" href="rss.aspx" /></head>
<a id="RssHyperLink1" href="rss.aspx">Teste</a>
 

Permitindo a inclusão de muitos novos feeds a uma página, com poucas linhas de código, bem como também permite a escolha de um canal específico quando o repositório for multicanal ou permite informar usuário quando o RSS exigir autenticação. Além disso, desde que o RssHyperlink herda várias funcionalidades do componente HyperLink é possível decorá-lo da mesma forma que sua classe pai, seja através de CSS, imagens ou outros detalhes.

Agora, sete a página Default.aspx como inicial, “Set as Start Page” no Solution Explorer, e pressione F5. Repare que na barra de endereços já pode ser encontrado o símbolo universal do RSS com a opção de inscrição assim que se clica com o botão esquerdo do mouse sobre ele, sendo o usuário dessa forma, direcionado para uma página semelhante a abaixo.

Bom, por hoje é só. No próximo artigo dessa série mostrarei que variadas opções de consumo de rss podem ser feitas, oferecendo inúmeras possibilidades de personalização de interface e consumo de feeds rss de terceiros. Até lá!!

Gostou? Faça o download do código fonte

Por Janio N. Lima

Leia Mais

Publicando RSS com PHP e MYSQL

Se você ainda não sabe o que é RSS, dê uma lida no post RSS e asp.net parte I , que você encontrará os conceitos introdutórios sobre o tema. 

1. Introdução

Para que qualquer site possa servir RSS, é necessário que ele forneça ao programa leitor, um arquivo XML, contendo os dados, pois RSS, como já sabemos, é nada mais que um arquivo XML que segue uma padronização da estrutura específica. Podemos fornecer esse XML de duas formas, ou através de um arquivo estático XML propriamente dito salvo em nosso servidor, ou por meio de uma página PHP que pode gerar esse XML dinamicamente para nós. No nosso caso vamos gerar por meio de uma página PHP.

Antes de partirmos para a feitura da página, precisamos antes guardar as informações que publicaremos no RSS em algum lugar. Na informática, lugar de armazenar informações é em banco de dados. No nosso caso usaremos o banco open-source MySQL, disponível para download em http://www.mysql.com.

2. Criando o banco de dados

A estrutura do arquivo RSS é bem definida. Temos as seguintes entidades Channel e Item, que possuem a seguinte estrutura e se relacionam da seguinte forma:

O script para criação dessa estrutura é este:

SET @OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS, UNIQUE_CHECKS=0;
SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0;
SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='TRADITIONAL';

CREATE SCHEMA IF NOT EXISTS `RSS` ;
USE `RSS`;

-- -----------------------------------------------------
-- Table `RSS`.`Channel`
-- -----------------------------------------------------
CREATE  TABLE IF NOT EXISTS `RSS`.`Channel` (
  `idChannel` INT NOT NULL AUTO_INCREMENT ,
  `title` VARCHAR(255) NULL DEFAULT NULL ,
  `link` VARCHAR(255) NULL DEFAULT NULL ,
  `description` TEXT NULL DEFAULT NULL ,
  PRIMARY KEY (`idChannel`) )
ENGINE = InnoDB;


-- -----------------------------------------------------
-- Table `RSS`.`Item`
-- -----------------------------------------------------
CREATE  TABLE IF NOT EXISTS `RSS`.`Item` (
  `idItem` INT NOT NULL AUTO_INCREMENT ,
  `title` VARCHAR(255) NULL DEFAULT NULL ,
  `link` VARCHAR(255) NULL DEFAULT NULL ,
  `description` TEXT NULL DEFAULT NULL ,
  `idChannel` INT NULL DEFAULT NULL ,
  PRIMARY KEY (`idItem`) ,
  CONSTRAINT `fk_Item_Channel`
    FOREIGN KEY (`idChannel` )
    REFERENCES `RSS`.`Channel` (`idChannel` )
    ON DELETE RESTRICT
    ON UPDATE CASCADE)
ENGINE = InnoDB;

CREATE INDEX fk_Item_Channel ON `RSS`.`Item` (`idChannel` ASC) ;



SET SQL_MODE=@OLD_SQL_MODE;
SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS;
SET UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS;

Você também pode baixá-lo na integra aqui.

Para excecutar o script de criação, podemos abrir o prompt de comando e simplesmente digitarmos:

shell> mysql < arquivo_texto

Também podemos abrir o client mysql e digirtarmos:

mysql> source filename

O client fará tudo de forma automatizada e teremos nosso banco de dados criado.

3. Criando a página PHP para geração do RSS

A página PHP gerará primeiro uma string contendo todo o XML, depois enviará para o leitor de RSS o resultado. Segue abaixo o código fonte da página PHP:

<?php
//criando cabeçalho do arquivo
$xml = '<?xml version="1.0" encoding="iso-8859-1"?>'."\n";
$xml .= '<rss version="2.0">'."\n";

//setando dados da conexao e do banco voce deve substituir pelos seus dados de conexão
$host = "mysql.test.com";
$user = "usuario";
$pass = "senha";
$db = "RSS";

//fazendo a conexão com o banco de dados que contem os dados RSS
mysql_connect($host, $user, $pass);
mysql_select_db($db);

//pegando dados do channel no banco
$sql = "SELECT idChannel, title, description, link FROM Channel ORDER BY idChannel DESC";
$reschan = mysql_query($sql);

//enquanto ainda houver dados do channelm executar codigo dentro do while
while ($rowchan = mysql_fetch_assoc($reschan))
{
    //abrindo tag do Channel
    // obs: \n = nova linha   
    $xml .= '<channel>'."\n";
   
    //formatando os dados nas tags rss do Channel   
    $xml .= '<title>'.htmlspecialchars($rowchan['title']).'</title>'."\n";
    $xml .= '<description>'.htmlspecialchars($rowchan['description']).'</description>'."\n";
    $xml .= '<link>'.htmlspecialchars($rowchan['link']).'</link>'."\n";
   
    //pegando dados dos Itens do Channel no banco de dados
    $sql = "SELECT title, link, description FROM Item WHERE idChannel = ".$rowchan['idChannel']." ORDER BY idItem DESC";
    $result = mysql_query($sql);
   
    //enquanto ainda houver itens no banco, executar codigo dentro do while
    while ($row = mysql_fetch_assoc($result))
    {
        //formatando dados do item nas tags RSS
        $xml .= '<item>'."\n";
        $xml .= '<title>'.htmlspecialchars($row['title']).'</title>'."\n";
        $xml .= '<description>'.htmlspecialchars($row['description']).'</description>'."\n";
        $xml .= '<link>'.htmlspecialchars($row['link']).'</link>'."\n";
        $xml .= '</item>'."\n";
    }
   
    //fechando tag do channel
    $xml .= '</channel>'."\n"; 
}

//fechando a tag rss
$xml .= '</rss>';

//retornando todo o xml pro leitor de rss do usuário
echo $xml;
?>

O código fonte acima pode ser baixado aqui. Salve a página PHP em seu servidor PHP e pronto! Bastará colocar o endereço da página no seu leitor de RSS e você verá que funciona!

4. Testando

Para testar o código da página PHP, fizemos um exemplo que você pode ver aqui. Se tudo der certo ao vizualizar no  Firefox você verá uma página semelhante a essa:

Por Solleon Menezes

Leia Mais