Importante: vamos encerrar o suporte à API Google Data v2.0 em 30 de setembro de 2024. Para garantir a funcionalidade contínua, atualize seus aplicativos que dependem da v2.0 do Google Data para a versão mais recente. Para a versão mais recente, use os links na barra de navegação do lado esquerdo. Observação: embora algumas solicitações GET (como postagens de listagem) continuem sendo aceitas como URLs de feed, há pequenas diferenças no comportamento delas. Para mais informações, consulte a documentação Blogger Help.
A API de dados do Blogger permite que aplicativos clientes visualizem e atualizem o Blogger conteúdo na forma de feeds da API de dados 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 algumas informações sobre os recursos do Blogger API de dados do Google, este documento fornece exemplos de interações básicas da API de dados usando a biblioteca de cliente.NET. Se você está interessado em entender mais sobre o protocolo subjacente que o usos da biblioteca, consulte a seção Protocolo da este guia do desenvolvedor.
Conteúdo
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ê compreende as ideias gerais por trás das APIs de dados do Google protocolo.
Para informações de referência sobre as classes e os métodos fornecidos pelo biblioteca cliente, consulte a API da biblioteca cliente.NET como referência. Para informações gerais de referência da API Blogger Data, consulte o Guia de referência de protocolo.
Primeiros passos
Para receber ajuda na 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 do
biblioteca de cliente, encontrará as DLLs necessárias para começar a
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. Portanto, se você já tem uma Conta do Google, está tudo pronto.
Como executar o código de amostra
Um cliente de exemplo totalmente funcional, 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 métodos username e
Os valores 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 executa várias operações no blog fornecido para demonstrar o uso da API Data do Blogger.
Para compilar os exemplos neste documento no 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 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ê quiser modificar os blogs, seu cliente precisará se autenticar antes de solicitar feeds particulares. 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 autenticação com as APIs de dados do Google em geral, consulte a página sobre a documentação Documentação.
Autenticação via proxy do AuthSub
A autenticação por proxy BYOL é usada por aplicativos da Web que precisam autenticam 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 informações mais detalhadas, consulte a documentação do OCR.
Quando um usuário visita seu aplicativo pela primeira vez, ele ainda não foi autenticado. Nesse caso, é necessário exibir algumas informações e um link direcionar o usuário a uma página do Google para autenticar sua solicitação de acesso ao em seus 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 do GenerativeRequest para seu aplicativo, crie uma string .NET da biblioteca de cliente da seguinte forma:
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,
que correspondem aos parâmetros de consulta usados pelo gerenciador de AuthSubRequest:
- 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.
- 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 faz a autenticação, o sistema AuthSub redireciona o usuário para o URL
especificado no parâmetro de consulta next do URL AuthSubRequest. O sistema BYOL anexa um token de autenticação a esse URL, pois a
do parâmetro de consulta token. Portanto, o token é
acessíveis como uma variável no arquivo Request.QueryString da página ASP
objeto. 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. Neste exemplo,
como session = true foi especificado, esse token pode ser trocado por
um token de sessão vezes, da seguinte forma:
SessionsessionToken = AuthSubUtil.exchangeForSessionToken(Request.QueryStringtoken, null);
Ou seja, você passa seu 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 chave
interface de usuário 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.
Seu aplicativo pode então usar o valor do token de sessão nas próximas interações 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 para 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 adquirem 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 de dados do Blogger fornece um feed que lista os blogs de um determinado user; esse feed é conhecido como "metafeed".
O exemplo de código a seguir usa um objeto Service autenticado
para recuperar o metafeed e, em seguida, imprime 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 padrão
URL metafeed; ela retorna uma lista de blogs para o usuário autenticado no momento.
Para acessar o feed de outro usuário, você pode colocar 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
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 presumem que você tem uma autenticação
Service.
Observação: definir um autor personalizado para as postagens é não tem suporte no momento. 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 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. 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 de 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 um ID de postagem.
Se a solicitação falhar por algum motivo, o Blogger poderá retornar um código de status diferente. Para mais informações sobre os códigos de status, consulte a Central de Ajuda Documento de referência do protocolo da API.
Como criar o rascunho de uma postagem do blog
As postagens de rascunho são criadas da mesma forma que as postagens públicas, mas é necessário definir
o atributo draft do objeto AtomEntry. O blog
a postagem 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 o rascunho de uma postagem do blog em uma publicação, recupere a postagem de rascunho, definindo o atributo rascunho como falso e atualizando o postagem. Vamos abordar a recuperação e a atualização de posts nas próximas duas seções.
Recuperando postagens
As seções a seguir descrevem como recuperar uma lista de postagens de blog, com e sem parâmetros de consulta.
Você pode consultar um feed público do Blogger sem autenticação. Portanto, você não é necessário definir credenciais ou fazer a autenticação StatefulSet antes da recuperação 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 de 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 o transmita para o
Service.Query().
Por exemplo, para enviar uma consulta de período, defina o MinPublication
e membros MaxPublication do objeto FeedQuery.
O snippet de código a seguir mostra o título de cada postagem do blog publicada entre
o horário de início e de término:
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 Data do Blogger é compatível com os 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. - 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 nas datas de atualização da entrada. Esses parâmetros de consulta são ignorados, a menos que o parâmetro
orderbyseja definido comoupdated.
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.
Atualizando postagens
Para atualizar uma postagem do blog, primeiro recupere a entrada que você quer
atualizar, modifique-a e envie para o Blogger usando o método
Update() da entrada. O snippet de código a seguir modifica o título de um
entrada do blog, supondo que você já tenha recuperado a entrada da
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 a string inteira
postagem atualizada recentemente. Para atualizar outras propriedades, basta defini-las no
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 de dados 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: configurar um autor personalizado para os comentários é não tem suporte no momento. Todos os novos comentários aparecerão como se tivessem sido criados por o usuário autenticado no momento.
Recuperando 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 receber 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 comentário
comente o objeto AtomEntry desta forma:
static void DeleteComment(AtomEntry commentEntry)
{
if (commentEntry != null)
{
// Delete the comment.
commentEntry.Delete();
}
}