Guia do desenvolvedor: .NET

Importante: esta é uma versão antiga desta página. Para usar a versão mais recente, use os links na barra de navegação à esquerda.

A API Data do Blogger permite que os aplicativos clientes acessem e atualizem o conteúdo do Blogger na forma de feeds da API Data do Google.

O aplicativo cliente pode usar a API Blogger Data para criar novas postagens do blog, editar ou excluir postagens existentes e consultar postagens que correspondem a critérios específicos.

Além de fornecer alguns antecedentes sobre os recursos da API Data do Blogger, este documento apresenta exemplos de interações básicas da API Data usando a biblioteca de cliente.NET. Se você quiser saber mais sobre o protocolo usado pela biblioteca, consulte a seção de protocolo deste guia para desenvolvedores.

Conteúdo

  1. Público
  2. Primeiros passos
    1. Como criar uma conta do Blogger
    2. Como executar o exemplo de código
  3. Como fazer a autenticação no serviço do Blogger
    1. Autenticação de proxy AuthSub
    2. Autenticação de nome de usuário/senha do ClientLogin
  4. Recuperando uma lista de blogs
  5. Como criar postagens
    1. Publicar uma postagem do blog
    2. Como criar um rascunho de postagem do blog
  6. Recuperando postagens
    1. Recuperando todas as postagens do blog
    2. Como recuperar postagens usando parâmetros de consulta
  7. Como atualizar postagens
  8. Como excluir postagens
  9. Comentários
    1. Como criar comentários
    2. Recuperando comentários
    3. Como excluir comentários

Público-alvo

Este documento é destinado a programadores que querem criar aplicativos cliente .NET que possam interagir com o Blogger.

Este documento pressupõe que você entenda as ideias gerais por trás do protocolo das APIs Data do Google.

Para informações de referência sobre as classes e os métodos fornecidos pela biblioteca de cliente, consulte a referência da API da biblioteca de cliente.NET. Para informações gerais de referência da API Data do Blogger, consulte o guia de referência do protocolo.

Primeiros passos

Para receber ajuda com a configuração da biblioteca de cliente, consulte o Guia de início.

Para usar a biblioteca de cliente .NET, você precisa do runtime .NET 1.1 e também precisa ter todos os patches atualizados. Depois de fazer o download da biblioteca de cliente, você vai encontrar as DLLs necessárias para começar no subdiretório lib/Release da distribuição.

Como criar uma conta do Blogger

Talvez seja melhor criar uma conta do Blogger para fins de teste. O Blogger usa Contas do Google. Se você já tem uma, está tudo pronto.

Como executar o código de amostra

Um cliente de exemplo completo, que contém todo o código de exemplo mostrado neste documento, está disponível no projeto da biblioteca de cliente .NET. A amostra está localizada em /trunk/clients/cs/samples/blogger/ConsoleSample.cs na guia "Source" do repositório SVN.

Antes de compilar e executar este exemplo, atualize os valores de username, password, blogName e postId com os valores adequados. Os valores username e password representam as credenciais usadas para fazer login no Blogger. O valor blogName é o início do URL do blogspot do seu blog.

O cliente de exemplo realiza várias operações no blog fornecido para demonstrar o uso da API Data do Blogger.

Para compilar os exemplos deste documento no seu próprio código, você vai precisar das seguintes instruções using:

using Google.GData.Client;
using System.Net;
using System.Xml;
using System.Text.RegularExpressions;

Como fazer a autenticação no serviço do Blogger

É possível acessar feeds públicos e privados usando a API Data do Blogger. Os feeds públicos não exigem autenticação, mas são somente leitura. Se você quer modificar blogs, seu cliente precisa se autenticar antes de solicitar feeds privados. Ele pode ser autenticado usando uma destas duas abordagens: autenticação de proxy AuthSub ou autenticação de nome de usuário/senha ClientLogin.

Para mais informações sobre a autenticação com as APIs de dados do Google em geral, consulte a documentação de autenticação.

Autenticação via proxy do AuthSub

A autenticação de proxy AuthSub é usada por aplicativos da Web que precisam autenticar os usuários nas Contas do Google. O operador do site e o código do cliente não têm acesso ao nome de usuário e à senha do usuário do Blogger. Em vez disso, o cliente recebe tokens AuthSub especiais que permitem que ele aja em nome de um usuário específico. Para mais informações, consulte a documentação do AuthSub.

Quando um usuário visita seu aplicativo pela primeira vez, ele ainda não foi autenticado. Nesse caso, você precisa mostrar algumas informações e um link direcionando o usuário a uma página do Google para autenticar sua solicitação de acesso aos blogs.

Suponha que o seguinte hiperlink ASP esteja definido na sua página:

<asp:HyperLink ID="GotoAuthSubLink" runat="server"/>

Em seguida, para construir o URL AuthSubRequest do seu aplicativo, faça uma chamada de biblioteca de cliente .NET da seguinte maneira:

GotoAuthSubLink.Text = "Login to your Google Account";
GotoAuthSubLink.NavigateUrl =
  AuthSubUtil.getRequestUrl("http://www.example.com/RetrieveToken",
  "http://www.blogger.com/feeds/",
  false,
  true);

O método getRequestUrl usa os seguintes parâmetros, correspondentes aos parâmetros de consulta usados pelo gerenciador de AuthSubRequest:

próxima
O URL da página para a qual o Google vai redirecionar o usuário após a autenticação.
escopo
Indica que o aplicativo está solicitando um token para acessar os feeds do Blogger. A string de escopo a ser usada é http://www.blogger.com/feeds/ (codificada por URL, é claro).
seguro
Indica se o cliente está solicitando um token seguro.
sessão
Indica se o token retornado pode ser trocado por um token de uso múltiplo (sessão).

O exemplo acima mostra uma chamada que não solicita um token seguro (o valor de secure é false). O URL de solicitação resultante pode ser parecido com este:

https://www.google.com/accounts/AuthSubRequest?scope=http%3A%2F%2Fwww.blogger.com%2Ffeeds%2F&session=1&secure=0&next=http%3A%2F%2Fwww.example.com%2FRetrieveToken

O usuário segue o link para o site do Google e faz a autenticação na Conta do Google.

Depois que o usuário é autenticado, o sistema AuthSub redireciona ele para o URL especificado no parâmetro de consulta next do URL AuthSubRequest. O sistema AuthSub anexa um token de autenticação a esse URL como o valor do parâmetro de consulta token. Portanto, o token é acessível como uma variável no objeto Request.QueryString da página ASP. O usuário é redirecionado para um URL parecido com este:

http://www.example.com/RetrieveToken?token=yourAuthToken

Esse valor de token representa um token AuthSub de um único uso. Neste exemplo, como session = true foi especificado, esse token pode ser trocado por um token de sessão do AuthSub, conforme mostrado abaixo:

SessionsessionToken = AuthSubUtil.exchangeForSessionToken(Request.QueryStringtoken, null);

Ou seja, você transmite seu token de uso único para o método exchangeForSessionToken, junto com null (para o modo não registrado) ou uma chave privada (para o modo registrado), e a interface AuthSub retorna um token de sessão. Para mais informações sobre aplicativos registrados e chaves privadas, consulte a seção Solicitações de assinatura da documentação do AuthSub.

O aplicativo pode usar o valor do token de sessão em interações posteriores com o Blogger. Para informar à biblioteca de cliente .NET que ela precisa enviar automaticamente o cabeçalho de autorização (que contém o token de sessão) com cada solicitação, faça o seguinte:

GAuthSubRequestFactory authFactory = new GAuthSubRequestFactory("blogger", "BloggerSampleApp");
authFactory.Token = SessionsessionToken.ToString();
Service service = new Service(authFactory.ApplicationName);
service.RequestFactory = authFactory;

Autenticação por nome de usuário/senha do ClientLogin

Use a autenticação ClientLogin se o cliente for um cliente "instalado" independente para um único usuário, como um aplicativo de computador. Defina as credenciais do objeto de serviço da seguinte maneira:

Service service = new Service("blogger", "exampleCo-exampleApp-1");
service.Credentials = new GDataCredentials("user@example.com", "secretPassword");
GDataGAuthRequestFactory factory = (GDataGAuthRequestFactory) service.RequestFactory;
factory.AccountType = "GOOGLE";

No snippet acima, transmitimos dois parâmetros para o construtor Service. O primeiro parâmetro é o nome do serviço com que queremos interagir. O segundo parâmetro é o nome do nosso aplicativo no formulário companyName-applicationName-versionID. Também definimos o Service.RequestFactory para usar apenas um tipo de conta GOOGLE para permitir a autenticação adequada dos usuários do G Suite.

Para mais informações sobre a autenticação do ClientLogin, incluindo solicitações e respostas de exemplo, consulte a documentação Autenticação para aplicativos instalados.

Observação: use o mesmo token para todas as solicitações em uma determinada sessão. Não adquira um novo token para cada solicitação do Blogger.

Observação: conforme descrito na documentação do ClientLogin, a solicitação de autenticação pode falhar e solicitar um desafio do CAPTCHA. Se você quiser que o Google emita e processe o desafio do CAPTCHA, envie o usuário para https://www.google.com/accounts/DisplayUnlockCaptcha?service=blogger (em vez do URL de processamento do CAPTCHA fornecido na documentação do ClientLogin).

Como extrair uma lista de blogs

A API Data do Blogger fornece um feed que lista os blogs de um usuário específico. Esse feed é conhecido como "metafeed".

O código de exemplo a seguir usa um objeto Service autenticado para extrair o metafeed e imprimir o título de cada blog.

query.Uri = new Uri("http://www.blogger.com/feeds/default/blogs");
AtomFeed feed = null;
try
{
  feed = service.Query(query);
  foreach (AtomEntry entry in feed.Entries)
  {
    Console.WriteLine("Blog Title: " + entry.Title.Text);
  }
}

Anote o URL usado pelo método getFeed. Esse é o URL de metafeed padrão. Ele retorna uma lista de blogs do usuário autenticado. Para acessar um feed de outro usuário, coloque o ID dele no lugar de default no URL do metafeed. O ID do usuário é a string de dígitos no final do URL do perfil do usuário.

Como criar postagens

A API Data do Blogger permite criar e publicar novas entradas de blog, além de criar rascunhos de entradas.

Todos os exemplos a seguir pressupõem que você tenha um objeto Service autenticado.

Observação: no momento, não é possível definir um autor personalizado para as postagens. Todas as novas postagens vão aparecer como se tivessem sido criadas pelo usuário autenticado no momento.

Publicar uma postagem do blog

Você pode usar a biblioteca de cliente .NET para publicar novas entradas de blog.

Primeiro, crie um objeto AtomEntry para representar a postagem do blog. Em seguida, você pode definir o título, o conteúdo e outros atributos da postagem do blog. Por fim, use o objeto Service para inserir a postagem. Confira um exemplo de como publicar uma nova postagem de blog:

AtomEntry newPost = new AtomEntry();
newPost.Title.Text = "Marriage!";
newPost.Content = new AtomContent();
newPost.Content.Content = "<div xmlns='http://www.w3.org/1999/xhtml'>" +
  "<p>Mr. Darcy has <em>proposed marriage</em> to me!</p>" +
  "<p>He is the last man on earth I would ever desire to marry.</p>" +
  "<p>Whatever shall I do?</p>" +
  "</div>";
newPost.Content.Type = "xhtml";

Uri blogFeedUri = new Uri("http://www.blogger.com/feeds/" + blogId + "/posts/default");
AtomEntry createdEntry = service.Insert(blogFeedUri, newPost);

O método Insert usa o URL de postagem do serviço como parâmetro. Em seguida, o método retorna a entrada conforme ela foi armazenada pelo Blogger. A entrada retornada é a mesma que você enviou, mas também contém vários elementos adicionados pelo Blogger, como um ID de postagem.

Se a solicitação falhar por algum motivo, o Blogger poderá retornar um código de status diferente. Para saber mais sobre os códigos de status, consulte o documento de referência do protocolo da API Google Data.

Criar um rascunho de postagem do blog

As postagens pendentes são criadas da mesma forma que as postagens públicas, mas você precisa definir o atributo draft do objeto AtomEntry. A postagem do blog acima pode ser criada como um rascunho adicionando a linha destacada:

AtomEntry newPost = new AtomEntry();
newPost.Title.Text = "Marriage!";
newPost.Content = new AtomContent();
newPost.Content.Content = "<div xmlns='http://www.w3.org/1999/xhtml'>" +
    "<p>Mr. Darcy has <em>proposed marriage</em> to me!</p>" +
    "<p>He is the last man on earth I would ever desire to marry.</p>" +
    "<p>Whatever shall I do?</p>" +
    "</div>";
newPost.Content.Type = "xhtml";
newPost.IsDraft = true;

Uri blogFeedUri = new Uri("http://www.blogger.com/feeds/" + blogId + "/posts/default");
AtomEntry createdEntry = service.Insert(blogFeedUri, newPost);

Para transformar um rascunho de postagem do blog em uma postagem publicada, recupere o rascunho, defina o atributo de rascunho como falso e atualize a postagem. Vamos abordar a recuperação e a atualização de posts nas próximas duas seções.

Como recuperar postagens

As seções a seguir descrevem como recuperar uma lista de postagens do blog, com e sem parâmetros de consulta.

É possível consultar um feed público do Blogger sem autenticação. Portanto, não é necessário definir credenciais ou fazer a autenticação do AuthSub antes de extrair postagens de um blog público.

Recuperação de todas as postagens do blog

Para recuperar as postagens do usuário, chame o mesmo método getFeed usado para recuperar o metafeed dos blogs, mas envie o URL do feed de postagens do blog:

query.Uri = new Uri("http://www.blogger.com/feeds/" + blogId + "/posts/default");
feed = service.Query(query);
Console.WriteLine(feed.Title.Text);
foreach (AtomEntry entry in feed.Entries)
{
  Console.WriteLine("Entry Title: " + entry.Title.Text);
}

Como recuperar postagens usando parâmetros de consulta

A API Blogger Data permite solicitar um conjunto de entradas que correspondem a critérios especificados, como solicitar postagens do blog publicadas ou atualizadas em um determinado período. Para fazer isso, crie um objeto FeedQuery e transmita-o ao método Service.Query().

Por exemplo, para enviar uma consulta de período, defina os membros MinPublication e MaxPublication do objeto FeedQuery. O snippet de código abaixo mostra o título de cada postagem do blog publicada entre o horário de início e de término especificados:

FeedQuery query = new FeedQuery();
query.Uri = new Uri("http://www.blogger.com/feeds/" + blogId + "/posts/default");
query.MinPublication = new DateTime(2006, 1, 1);
query.MaxPublication = new DateTime(2007, 4, 12);
AtomFeed feed = service.Query(query);
foreach (AtomEntry entry in feed.Entries)
{
  Console.WriteLine("  Entry Title: " + entry.Title.Text);
}

O objeto FeedQuery é criado usando o mesmo URL do feed de postagens usado para extrair postagens.

A API Data do Blogger é compatível com os seguintes parâmetros de consulta:

alt
O tipo de feed a ser retornado, como atom (padrão) ou rss.
/category
Especifique categorias (também conhecidas como rótulos) para filtrar os resultados do feed. Por exemplo, http://www.blogger.com/feeds/blogID/posts/default/-/Fritz/Laurie retorna entradas com os rótulos Fritz e Laurie.
max-results
O número máximo de entradas a serem retornadas.
orderby
A ordem em que as entradas serão retornadas, como lastmodified (padrão), starttime ou updated.
published-min, published-max
Os limites das datas de publicação da entrada.
start-index
O índice com base em 1 do primeiro resultado a ser recuperado (para paginação).
updated-min, updated-max
Os limites nas datas de atualização da entrada. Esses parâmetros de consulta são ignorados, a menos que o parâmetro orderby seja definido como updated.

Para mais informações sobre parâmetros de consulta, consulte o Guia de referência da API Data do Blogger e o Guia de referência das APIs Data do Google.

Como atualizar postagens

Para atualizar uma postagem de blog, primeiro recupere a entrada que você quer atualizar, modifique-a e envie-a ao Blogger usando o método Update() da entrada. O snippet de código a seguir modifica o título de uma entrada de blog, presumindo que você já tenha extraído a entrada do servidor.

static AtomEntry EditEntry(AtomEntry toEdit)
{
  // Edit the entry by changing the Title and calling Update().
  if (toEdit != null)
  {
    toEdit.Title.Text = "Marriage Woes!";
    toEdit = toEdit.Update();
  }
  return toEdit;
}

O código acima retorna um AtomEntry contendo toda a postagem recém-atualizada. Para atualizar outras propriedades, basta defini-las no objeto AtomEntry antes de chamar Update().

Observação: no momento, não é possível modificar os dados do autor associados às postagens.

Como excluir postagens

Para excluir uma postagem, chame o método Delete em um objeto AtomEntry existente, como este:

static void DeleteEntry(AtomEntry toDelete)
{
  // Delete the edited entry
  if (toDelete != null)
  {
    toDelete.Delete();
  }
}

Comentários

A API Data do Blogger permite criar, recuperar e excluir comentários. Não é possível atualizar comentários nem usar esse recurso na interface da Web.

Como criar comentários

Para postar um comentário, crie um objeto AtomEntry e insira da seguinte maneira:

AtomEntry comment;
comment = new AtomEntry();
comment.Title.Text = "This is my first comment";
comment.Content.Content = "This is my first comment";
Uri commentPostUri = new Uri("http://www.blogger.com/feeds/" + blogId + "/" + entryId + "/comments/default");
postedComment = service.Insert(commentPostUri, comment);

Observação: no momento, só é possível postar comentários em um blog que pertence ao usuário autenticado.

Observação: no momento, não é possível definir um autor personalizado para comentários. Todos os novos comentários vão aparecer como se tivessem sido criados pelo usuário autenticado no momento.

Como recuperar comentários

É possível recuperar os comentários de uma postagem específica pelo URL do feed de comentários:

static void ListEntryComments(Service service, Uri commentUri)
{
  if (commentUri != null)
  {
    // Retrieve all comments on a blog entry
    FeedQuery query = new FeedQuery();
    query.Uri = commentUri;
    AtomFeed feed = service.Query(query);
    foreach (AtomEntry entry in feed.Entries)
    {
      Console.WriteLine("  Comment Title: " + entry.Title.Text);
    }
  }
}

Ou você pode usar o URL do feed de comentários do blog para receber os comentários de todas as postagens:

http://www.blogger.com/feeds/blogID/comments/default

Excluir comentários

Para excluir um comentário, chame o método Delete() em um objeto de comentário AtomEntry existente, como este:

static void DeleteComment(AtomEntry commentEntry)
{
  if (commentEntry != null)
  {
    // Delete the comment.
    commentEntry.Delete();
  }
}

Voltar ao início