Importante: vamos descontinuar o suporte à API Google Data v2.0 em 30 de setembro de 2024. Para garantir a funcionalidade contínua, atualize os aplicativos que dependem da API Google Data v2.0 para a versão mais recente. Para a versão mais recente, use os links na barra de navegação à esquerda. Observação: algumas solicitações GET (como postagens de fichas de empresas) continuarão sendo compatíveis como URLs de feed, mas há pequenas diferenças no comportamento. Para informações detalhadas, consulte a documentação da Ajuda do Blogger.
Com a API de dados do Blogger, os aplicativos clientes podem visualizar e atualizar o conteúdo do Blogger na forma de feeds da API Google Data.
Seu aplicativo cliente pode usar a API Blogger Data para criar novas postagens de blog, editar ou excluir postagens de blog existentes e consultar publicações que correspondam a critérios específicos.
Além de apresentar algumas informações sobre os recursos da API Blogger Data, 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 subjacente que a biblioteca usa, consulte a seção Protocolo deste guia para desenvolvedores.
Conteúdo
Público-alvo
Este documento se destina a programadores que desejam criar aplicativos cliente .NET que possam interagir com o Blogger.
Neste documento, presumimos que você entenda as ideias gerais por trás do protocolo de 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 ao configurar a biblioteca de cliente, consulte o Guia de primeiros passos.
Para usar a biblioteca de cliente .NET, é necessário ter o ambiente de execução do .NET 1.1 e estar atualizado em 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 realizar um teste. O Blogger usa as Contas do Google. Portanto, se você já tem uma Conta do Google, não precisa fazer mais nada.
Como executar o código de amostra
Um cliente de amostra funcional completo, contendo todo o exemplo de código mostrado neste documento, está disponível no projeto da biblioteca de cliente .NET. O exemplo está localizado 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 Blogger Data.
Para compilar os exemplos neste documento em seu próprio 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. Ele pode autenticar usando uma destas duas abordagens: autenticação de proxy do AuthSub ou a autenticação de nome de usuário/senha do ClientLogin.
Para mais informações sobre 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 por proxy do Ctrl é usada por aplicativos da Web que precisam autenticar seus 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 mudo especiais que permitem que ele aja em nome de um determinado usuário. Para informações mais detalhadas, consulte a documentação do Twilio.
Quando um usuário acessa seu aplicativo pela primeira vez, ele ainda não foi autenticado. Nesse caso, é preciso exibir algumas informações e um link que direcione 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 gclidRequest 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 DoFnRequest:
- próxima
- O URL da página para onde o Google precisa 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 para 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.
Depois que o usuário se autentica, o sistema DRM o redireciona para o URL
especificado no parâmetro de consulta next do URL
do \{Request. O sistema ConstraintLayout 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 com a seguinte aparência:
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 gclid da seguinte forma:
SessionsessionToken = AuthSubUtil.exchangeForSessionToken(Request.QueryStringtoken, null);
Ou seja, você transmite o token de uso único para o método
exchangeForSessionToken com null
(para o modo não registrado) ou uma chave privada (para o modo registrado), e a interface
o usa retorna um token de sessão. Para saber mais sobre aplicativos registrados e chaves privadas, consulte a seção "Solicitações de assinatura" da documentação do Twilio.
Seu aplicativo poderá usar o valor do token de sessão nas 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 ChromeVox se o cliente for um cliente "instalado" independente e de 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 o qual 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, permitindo a autenticação adequada para usuários do G Suite.
Para mais informações sobre a autenticação do ChromeVox, incluindo exemplos de solicitações e respostas, consulte a documentação Autenticação de 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 ChromeVox, a solicitação de autenticação pode falhar e solicitar um desafio
CAPTCHA. Se você quiser que o Google emita e lide com o desafio CAPTCHA, envie o usuário para
https://www.google.com/accounts/DisplayUnlockCaptcha?service=blogger
(em vez de para o URL de processamento de CAPTCHA fornecido na documentação
do ChromeVox).
Como recuperar uma lista de blogs
A API Blogger Data 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 do metafeed padrão. Ele retorna uma lista de blogs do 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 sequência de dígitos
no final do URL do perfil do usuário.
Criar postagens
Com a API Blogger Data, você pode criar e publicar novas entradas de blog, além de criar rascunhos de entradas.
Em todos os exemplos a seguir, presume-se que você tenha um objeto Service autenticado.
Observação: no momento, não é possível definir um autor personalizado para postagens. Todas as novas postagens vão aparecer como se tivessem sido criadas pelo usuário autenticado no momento.
Publicar uma postagem no blog
Você pode usar a biblioteca de cliente .NET para publicar novas entradas no 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.
Por fim, use o objeto Service para inserir a postagem. Veja 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 um parâmetro.
Em seguida, o método retorna a entrada da forma 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 um ID de postagem.
Se a solicitação falhar por algum motivo, o Blogger pode retornar um código de status diferente. Para mais informações 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 de rascunho são criadas da mesma forma que as 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 o rascunho de uma postagem de blog em uma publicação publicada, recupere a postagem de rascunho, defina o atributo de rascunho como "false" e atualize a postagem. Abordaremos como recuperar e atualizar postagens 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.
Você pode consultar um feed público do Blogger sem autenticação. Portanto, você não precisa definir credenciais ou fazer a autenticação Nearline antes de recuperar postagens de um blog público.
Como recuperar 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 postagem 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
Com a API Blogger Data, você pode solicitar um conjunto de entradas que correspondam a critérios especificados, como a solicitação de postagens de 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 a seguir imprime 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 é 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) ourss. - /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/Laurieretorna entradas com os rótulosFritzeLaurie. - 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),starttimeouupdated. - mín. publicado, máx. publicado
- Os limites para as datas de publicação da entrada.
- start-index
- O índice baseado em 1 do primeiro resultado a ser recuperado (para paginação).
- mínimo atualizado, máximo atualizado
- Os limites para as datas de atualização de entradas. Esses parâmetros de consulta são ignorados, a menos que
orderbyseja definido comoupdated.
Para mais informações sobre os 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 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 do blog, supondo que você já recuperou 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.
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 estar 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 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 no 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 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
Excluir 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();
}
}