Guia do desenvolvedor: .NET

Importante: esta é uma versão antiga da página. Para a versão mais recente, use os links na barra de navegação do lado esquerdo.

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

Seu aplicativo cliente pode usar a API de dados do Blogger para criar novas postagens, editar ou excluir postagens existentes e consultar as postagens que correspondam a critérios específicos.

Além de fornecer algumas informações sobre os recursos da API de dados do Blogger, este documento mostra exemplos de interações básicas dessa API usando a biblioteca de cliente.NET. Se você tiver interesse em entender mais sobre o protocolo subjacente usado pela biblioteca, consulte a seção Protocolo deste Guia para desenvolvedores.

Conteúdo

  1. Público
  2. Como começar
    1. Como criar uma conta do Blogger
    2. Como executar o exemplo de código
  3. Como autenticar no serviço do Blogger
    1. Autenticação por proxy do AOSP
    2. Autenticação por nome de usuário/senha do PuTTY
  4. Como recuperar uma lista de blogs
  5. Criar postagens
    1. Publicar uma postagem do blog
    2. Como criar o rascunho de uma postagem do blog
  6. Recuperar postagens
    1. Recuperar 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. Recuperar comentários
    3. Como excluir comentários

Público

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

Este documento pressupõe que você compreende as ideias gerais por trás do protocolo das APIs de dados 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 Blogger Data, consulte o Guia de referência de protocolo.

Como começar

Para receber ajuda na configuração da biblioteca de cliente, consulte o Guia explicativo.

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

Como criar uma conta do Blogger

Recomendamos que você se inscreva em uma conta do Blogger para fins de teste. O Blogger usa Contas do Google. Portanto, se você já tem uma, não precisa fazer mais nada.

Como executar o código de amostra

Um cliente de amostra funcional completo, contendo todo o código de amostra 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 "Origem" do repositório SVN.

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

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

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

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

Como autenticar no serviço do Blogger

Você pode acessar feeds públicos e privados usando a API de dados do Blogger. Os feeds públicos não exigem autenticação, mas são somente leitura. Se você quiser modificar blogs, seu cliente precisará se autenticar antes de solicitar feeds particulares. A autenticação pode ser feita usando uma destas duas abordagens: autenticação de proxy AuthSub ou a autenticação de nome de usuário/senha do ClientLogin.

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

Autenticação via proxy do AuthSub

A autenticação por proxy BYOL é 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 MRAID especiais que permitem que ele atue em nome de um usuário específico. Para informações mais detalhadas, consulte a documentação do MRAID (em inglês).

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

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

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

Em seguida, para construir o URL de vezesRequest para 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 StatefulSetRequest):

próxima
O URL da página para onde o Google deve 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/ (codificado em URL, obviamente).
seguro
Indica se o cliente está solicitando um token seguro.
seção
Indica se o token retornado pode ser trocado por um token multiuso (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 ter esta aparência:

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.

Após a autenticação do usuário, o sistema StatefulSet redireciona o usuário para o URL especificado no parâmetro de consulta next desse URL. O sistema NGINX anexa um token de autenticação a esse URL, como o valor do parâmetro de consulta token. Portanto, o token pode ser acessado como uma variável no objeto Request.QueryString da página ASP. O usuário é redirecionado para um URL semelhante a este:

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

Esse valor de token representa um token AuthSub de um único uso. Nesse exemplo, como session = true foi especificado, esse token pode ser trocado por um token de sessão do StatefulSet da seguinte maneira:

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 modo registrado), e a interface noindex retorna um token de sessão. Para mais informações sobre aplicativos registrados e chaves privadas, consulte a seção "Assinar solicitações" da documentação do AOSP.

Seu aplicativo pode usar o valor do token de sessão em interações subsequentes com o Blogger. Para instruir a biblioteca de cliente .NET a enviar automaticamente o cabeçalho de autorização (contendo 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 GroupByKey se seu cliente for um cliente "instalado" independente e de usuário único (como um aplicativo de área de trabalho). 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 formato companyName-applicationName-versionID. Também definimos o Service.RequestFactory para usar apenas um tipo de conta GOOGLE a fim de permitir a autenticação adequada para usuários do G Suite.

Para mais informações sobre a autenticação do ConstraintLayout, incluindo exemplos de solicitações e respostas, 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 ConstraintLayout, a solicitação de autenticação pode falhar e solicitar um desafio de CAPTCHA. Se você quiser que o Google emita e lide com o desafio CAPTCHA, encaminhe o usuário para https://www.google.com/accounts/DisplayUnlockCaptcha?service=blogger (e não para o URL de processamento de CAPTCHA fornecido na documentação do Systrace).

Como recuperar uma lista de blogs

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

O exemplo de código a seguir usa um objeto Service autenticado para recuperar 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);
  }
}

Observe o URL usado pelo método getFeed. Esse é o URL de metafeed padrão. Ele retorna uma lista de blogs para o usuário autenticado no momento. Para acessar o feed de outro usuário, coloque o ID do usuário 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

Com a API Blogger Data, você pode criar e publicar novas entradas de blog, além de criar rascunhos de entradas.

Todos os exemplos a seguir presumem 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 serão exibidas como se tivessem sido criadas pelo usuário autenticado no momento.

Publicar uma postagem do blog

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

Primeiro, crie um objeto AtomEntry para representar a postagem do blog. Em seguida, defina 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 do 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 da postagem do serviço como parâmetro. Em seguida, o método retorna a entrada como 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 o ID da 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.

Como criar o rascunho de uma postagem do blog

Os rascunhos de postagens são criados da mesma forma que as públicas, mas é necessário definir o atributo draft do objeto AtomEntry. A postagem do blog acima pode ser criada como 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 publicada, basta recuperar a postagem de rascunho, definir o atributo de rascunho como falso e atualizar a postagem. Abordaremos como recuperar e atualizar postagens nas próximas duas seções.

Recuperando postagens

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

Você pode consultar um feed público do Blogger sem autenticação. Portanto, não é necessário definir credenciais ou fazer a autenticação do StatefulSet antes de recuperar postagens de um blog público.

Recuperando 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 da postagem do blog desta vez:

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

Com a API Blogger Data, você pode solicitar um conjunto de entradas que correspondam 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 para o 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 os horários 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 é construído usando o mesmo URL do feed de postagens usado para recuperar postagens.

A API de dados do Blogger oferece suporte aos seguintes parâmetros de consulta:

alt
O tipo de feed a ser retornado, como atom (padrão) ou rss.
/category
Especificar 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 são retornadas, como lastmodified (padrão), starttime ou updated.
min-publicado, máx.-publicado
Os limites para as datas de publicação das inscrições.
start-index
O índice baseado em 1 do primeiro resultado a ser recuperado (para paginação).
min-atualizado, máx. atualizado
Os limites para as datas de atualização das entradas. Esses parâmetros de consulta serã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 Blogger Data e o Guia de referência das APIs Google Data.

Atualizando postagens

Para atualizar uma postagem do blog, primeiro recupere a entrada que você quer atualizar. Em seguida, modifique-a e envie-a para o Blogger usando o método Update() da entrada. O snippet de código a seguir modifica o título de uma entrada do blog, supondo que você já a tenha recuperado 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 que contém 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.

Excluindo postagens

Para excluir uma postagem, chame o método Delete em um objeto AtomEntry já existente, desta forma:

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

Comentários

A API de dados do Blogger permite criar, recuperar e excluir comentários. Não é possível atualizar comentários (nem disponível na interface da Web).

Como criar comentários

Para postar um comentário, crie um objeto AtomEntry e insira-o 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 de propriedade do usuário autenticado.

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

Recuperando comentários

Você pode recuperar os comentários de uma postagem específica no URL do feed de comentários da postagem:

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 obter os comentários de todas as postagens usando o URL do feed de comentários do blog:

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

Excluindo comentários

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

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

Voltar ao início