A API de dados do Blogger permite que aplicativos cliente vejam e atualizem o conteúdo do Blogger na forma de feeds da API Google Data.
Seu aplicativo cliente pode usar a API de dados do Blogger para criar novas postagens de blog, editar ou excluir postagens de blog existentes e consultar postagens de blog que correspondam a critérios específicos.
Além de fornecer 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ê tiver interesse em entender mais sobre o protocolo subjacente usado pela biblioteca, consulte a seção de protocolo deste guia do desenvolvedor.
Índice
Público-alvo
Este documento é destinado a programadores que querem criar aplicativos clientes .NET que possam interagir com o Blogger.
Neste documento, presumimos que você entenda 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 do .NET. Para informações gerais de referência da API de dados do Blogger, consulte o Guia de referência de protocolos.
Primeiros passos
Se você precisar de ajuda para configurar a biblioteca de cliente, consulte o Guia de primeiros passos.
Para usar a biblioteca de cliente .NET, você precisará do ambiente de execução do .NET 1.1, além de 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.
Criar uma conta do Blogger
Inscreva-se em uma conta do Blogger para fins de teste. O Blogger usa as 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 completo, contendo todo o código de amostra mostrado neste documento, está disponível no projeto da biblioteca de cliente do .NET. A amostra está localizada em /tron/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 apropriados. 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 blog
em seu blog.
O cliente de amostra executa várias operações no blog fornecido para demonstrar o uso da API de dados do Blogger.
Para compilar os exemplos deste 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 privados. Ele pode se autenticar usando uma das duas abordagens: autenticação de proxy SMTP ou 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 de proxy dSYM é 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 dSYM especiais que permitem ao cliente agir em nome de um usuário específico. Para informações mais detalhadas, consulte a documentação do SWF.
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 que direcione o usuário para uma página do Google para autenticar sua solicitação de acesso aos blogs.
Suponha que o hiperlink ASP abaixo esteja definido na sua página:
<asp:HyperLink ID="GotoAuthSubLink" runat="server"/>
Em seguida, para criar o URL dSYMRequest para seu aplicativo, faça uma chamada para a 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 dSYMRequest):
- próxima
- O URL da página a que o Google deve redirecionar o usuário após a autenticação.
- escopo
- Indica que o aplicativo está solicitando um token para acessar feeds do Blogger. A string do escopo a ser usada é
http://www.blogger.com/feeds/
(codificada para URL, é claro). - proteger
- 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 poderá ter a seguinte 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 faz a autenticação, o sistema dSYM os redireciona para o URL especificado no parâmetro de consulta next
do URL de dSYMRequest. O sistema dSYM 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 a 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 dSYM, da seguinte maneira:
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 dSYM
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 dSYM.
O aplicativo pode usar o valor do token de sessão em interações subsequentes com o Blogger. Para solicitar que a biblioteca de cliente .NET envie automaticamente o cabeçalho de autorização (contendo o token de sessão) a 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 independente"instalado"(como um aplicativo de desktop). 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
Service.RequestFactory
para usar apenas um tipo de conta GOOGLE
para permitir uma autenticação adequada para usuários do G Suite.
Para mais informações sobre a autenticação do ClientLogin, incluindo solicitações e respostas de amostra, consulte a documentação de Autenticação em 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 CAPTCHA. Se você quiser que o Google emita e processe o desafio CAPTCHA, envie o usuário para
https://www.google.com/accounts/DisplayUnlockCaptcha?service=blogger
,
em vez do URL de gerenciamento do CAPTCHA fornecido na documentação do
ClientLogin.
Recuperar uma lista de blogs
A API de dados do Blogger fornece um feed que lista os blogs para 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
. Este é o URL do metafeed padrão. Ele retorna uma lista de blogs para o usuário autenticado no momento.
Para acessar um feed de um usuário diferente, coloque o ID do usuário em vez 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 de dados do Blogger permite criar e publicar novas entradas de blog, bem como criar rascunhos de entradas.
Nas amostras a seguir, presumimos 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 aparecerão como se tivessem sido criadas pelo usuário autenticado no momento.
Publicar uma postagem do blog
É possível usar a biblioteca de cliente .NET para publicar novas entradas de blog.
Primeiro, crie um objeto AtomEntry
para representar a postagem do blog.
Depois você pode definir 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 de postagem do serviço como um 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 sua solicitação falhar por algum motivo, o Blogger pode retornar um código de status diferente. Para informações sobre os códigos de status, consulte o documento de referência do protocolo da API Google Data.
Criando um rascunho de postagem do blog
Os rascunhos de postagens são criados 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 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 uma postagem do blog atual em uma postagem publicada, recupere a postagem de rascunho, defina o atributo rascunho como falso e atualize a postagem. Falaremos sobre como recuperar e atualizar postagens nas próximas duas seções.
Recuperar 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 precisa definir credenciais ou fazer a autenticação dSYM antes de recuperar postagens de um blog público.
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, desta vez, envie o URL do feed da 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 de dados do Blogger, você pode solicitar um conjunto de entradas que correspondam a critérios específicos, como a solicitação de postagens do blog publicadas ou atualizadas em um determinado período. Para fazer isso, crie um objeto FeedQuery
e o transmita 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
os horários de início e término informados:
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 recuperar postagens.
A API de dados do Blogger aceita os seguintes parâmetros de consulta:
- alt
- O tipo de feed a ser retornado, como
atom
(o padrão) ourss
. - /category
- Especifique as 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ótulosFritz
eLaurie
. - 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
ouupdated
. - min-min, publicado-max
- Os limites nas datas de publicação das entradas.
- start-index
- O índice baseado em 1 do primeiro resultado a ser recuperado (para paginação).
- minutos de atualização, máximo de atualizações
- Os limites nas datas de atualização de entrada. Esses parâmetros de consulta são ignorados a menos que o parâmetro
orderby
esteja definido comoupdated
.
Para mais informações sobre os parâmetros de consulta, consulte o Guia de referência da API de dados do Blogger e o Guia de referência das APIs de dados do Google.
Atualizando postagens
Para atualizar uma postagem do blog existente, primeiro recupere a entrada que você quer
atualizar, modifique-a e envie-a ao Blogger usando o método
Update()
de entrada. O snippet de código a seguir modifica o título de uma
entrada de blog, supondo que você já tenha recuperado 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 a postagem
completamente 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 a postagens.
Como excluir postagens
Para excluir uma postagem, chame o método Delete
em um objeto AtomEntry
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).
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.
Como recuperar comentários
Você pode recuperar os comentários de uma postagem específica no URL de 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, para ver os comentários de todas as postagens, use o URL do feed de comentários do blog:
http://www.blogger.com/feeds/blogID/comments/default
Como 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(); } }