Cette page a été traduite par l'API Cloud Translation.

Guide du développeur: .NET

L'API Blogger Data permet aux applications clientes d'afficher et de mettre à jour le contenu de Blogger sous la forme de flux d'API Google Data.

Votre application cliente peut utiliser l'API Blogger Data pour créer des articles de blog, modifier ou supprimer des articles de blog existants et rechercher des articles de blog correspondant à des critères particuliers.

En plus de vous familiariser avec les fonctionnalités de l'API Data de Blogger, ce document fournit des exemples d'interactions de l'API Data de base avec la bibliothèque cliente .NET. Si vous souhaitez en savoir plus sur le protocole sous-jacent utilisé par la bibliothèque, consultez la section Protocole de ce guide du développeur.

Contenus

Audience

Ce document est destiné aux programmeurs qui souhaitent écrire des applications clientes .NET pouvant interagir avec Blogger.

Dans ce document, nous partons du principe que vous comprenez les principes généraux du protocole Google Data APIs.

Pour plus d'informations sur les classes et les méthodes fournies par la bibliothèque cliente, consultez la documentation de référence de l'API.NET pour la bibliothèque cliente. Pour obtenir des informations générales sur l'API Data de Blogger, consultez le Guide de référence du protocole.

Commencer

Si vous avez besoin d'aide pour configurer la bibliothèque cliente, consultez le guide de démarrage.

Pour utiliser la bibliothèque cliente .NET, vous devez disposer de l'environnement d'exécution .NET 1.1 et vous devez également être à jour sur tous les correctifs. Après avoir téléchargé la bibliothèque cliente, vous trouverez les DLL dont vous avez besoin pour vous lancer dans le sous-répertoire lib/Release de la distribution.

Créer un compte Blogger

Vous pouvez créer un compte Blogger à des fins de test. Blogger utilise les comptes Google. Si vous en avez déjà un, vous n'avez rien à faire.

Exécuter l'exemple de code

Un exemple de client complet, contenant tous les exemples de code présentés dans ce document, est disponible dans le projet de bibliothèque cliente .NET. L'exemple se trouve à l'emplacement /jonction/clients/cs/samples/blogger/ConsoleSample.cs dans l'onglet "Source" du dépôt SVN.

Avant de compiler et d'exécuter cet exemple, mettez à jour les valeurs de username, password, blogName et postId. Les valeurs username et password représentent les identifiants utilisés pour se connecter à Blogger. La valeur blogName est le début de l'URL blogspot de votre blog.

L'exemple de client effectue plusieurs opérations sur le blog fourni pour illustrer l'utilisation de l'API Data de Blogger.

Pour compiler les exemples de ce document dans votre propre code, vous devez disposer des instructions using suivantes:

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

S'authentifier sur le service Blogger

Vous pouvez accéder aux flux publics et privés à l'aide de l'API Blogger Data. Les flux publics ne requièrent aucune authentification, mais ils sont en lecture seule. Si vous souhaitez modifier des blogs, votre client doit s'authentifier avant de demander des flux privés. Il peut s'authentifier de deux manières : l'authentification par proxy AuthSub ou l'authentification par nom d'utilisateur/mot de passe ClientLogin.

Pour en savoir plus sur l'authentification auprès des API Google Data en général, consultez la documentation sur l'authentification.

Authentification du proxy AuthSub

L'authentification de proxy AuthSub est utilisée par les applications Web qui doivent authentifier leurs utilisateurs auprès de comptes Google. L'opérateur du site Web et le code client n'ont pas accès au nom d'utilisateur ni au mot de passe de l'utilisateur Blogger. À la place, le client obtient des jetons AuthSub spéciaux qui lui permettent d'agir pour le compte d'un utilisateur particulier. Pour en savoir plus, consultez la documentation AuthSub.

Lorsqu'un utilisateur visite votre application pour la première fois, il n'a pas encore été authentifié. Dans ce cas, vous devez afficher des informations et un lien redirigeant l'utilisateur vers une page Google afin d'authentifier votre demande d'accès à ses blogs.

Supposons que le lien hypertexte ASP suivant soit défini sur votre page:

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

Ensuite, pour créer l'URL AuthSubRequest pour votre application, effectuez un appel de la bibliothèque cliente .NET comme suit:

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

La méthode getRequestUrl utilise les paramètres suivants (correspondant aux paramètres de requête utilisés par le gestionnaire AuthSubRequest):

suivant: URL de la page vers laquelle Google doit rediriger l'utilisateur après l'authentification.
champ d'application: Indique que l'application demande un jeton pour accéder aux flux Blogger. La chaîne du champ d'application à utiliser est http://www.blogger.com/feeds/ (encodé en URL, évidemment).
sécurisé: Indique si le client demande un jeton sécurisé.
session: Indique si le jeton renvoyé peut être échangé contre un jeton à usages multiples (session).

L'exemple ci-dessus montre un appel qui ne demande pas de jeton sécurisé (la valeur de secure est false). L'URL de requête obtenue peut se présenter comme suit:

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

L'utilisateur suit le lien vers le site de Google et s'authentifie sur son compte Google.

Une fois l'authentification de l'utilisateur effectuée, le système AuthSub le redirige vers l'URL que vous avez spécifiée dans le paramètre de requête next de l'URL AuthSubRequest. Le système AuthSub ajoute un jeton d'authentification à cette URL, en tant que valeur du paramètre de requête token. Par conséquent, le jeton est accessible en tant que variable dans l'objet Request.QueryString de la page ASP. L'utilisateur est redirigé vers une URL semblable à celle-ci:

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

Cette valeur de jeton représente un jeton AuthSub à usage unique. Dans cet exemple, étant donné que session = true a été spécifié, ce jeton peut être échangé contre un jeton de session AuthSub, comme suit:

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

Autrement dit, vous transmettez votre jeton à usage unique à la méthode exchangeForSessionToken, ainsi que null (pour le mode non enregistré) ou une clé privée (pour le mode enregistré). L'interface AuthSub renvoie alors un jeton de session. Pour en savoir plus sur les applications enregistrées et les clés privées, consultez la section Signer des requêtes de la documentation AuthSub.

Votre application peut ensuite utiliser la valeur du jeton de session lors des interactions ultérieures avec Blogger. Pour indiquer à la bibliothèque cliente .NET d'envoyer automatiquement l'en-tête Authorization (contenant le jeton de session) à chaque requête, procédez comme suit:

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

Authentification du nom d'utilisateur/mot de passe ClientLogin

Utilisez ClientLogin si votre client est un client autonome à installation unique (application de bureau, par exemple). Définissez les identifiants de votre objet de service comme suit:

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

Dans l'extrait de code ci-dessus, nous transmettons deux paramètres au constructeur Service. Le premier paramètre correspond au nom du service avec lequel nous voulons interagir. Le deuxième paramètre correspond au nom de notre application, au format companyName-applicationName-versionID. Nous définissons également Service.RequestFactory pour n'utiliser qu'un type de compte GOOGLE afin de permettre une authentification appropriée pour les utilisateurs de G Suite.

Pour plus d'informations sur l'authentification ClientLogin, y compris des exemples de requêtes et de réponses, consultez la documentation Authentification pour les applications installées.

Remarque : Utilisez le même jeton pour toutes les requêtes d'une session donnée. N'acquérez pas de nouveau jeton pour chaque requête Blogger.

Remarque: Comme décrit dans la documentation ClientLogin, la requête d'authentification peut échouer et entraîner un test CAPTCHA. Si vous souhaitez que Google émette et gère le test CAPTCHA, envoyez l'utilisateur vers https://www.google.com/accounts/DisplayUnlockCaptcha?service=blogger (plutôt que vers l'URL de traitement CAPTCHA fournie dans la documentation ClientLogin).

Récupérer une liste de blogs

L'API Blogger Data fournit un flux qui répertorie les blogs d'un utilisateur particulier. Ce flux est appelé "metafeed".

L'exemple de code suivant utilise un objet Service authentifié pour récupérer le métaflux, puis imprime le titre de chaque 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);
  }
}

Notez l'URL utilisée par la méthode getFeed. Il s'agit de l'URL du métaflux par défaut. Elle renvoie la liste des blogs de l'utilisateur actuellement authentifié. Pour accéder au flux d'un autre utilisateur, vous pouvez remplacer l'ID de l'utilisateur par default dans l'URL du métaflux. L'ID utilisateur correspond à la chaîne de chiffres située à la fin de l'URL du profil de l'utilisateur.

Création de posts

L'API Blogger Data vous permet de créer et de publier de nouvelles entrées de blog, mais aussi de créer des brouillons d'entrées.

Tous les exemples suivants supposent que vous disposez d'un objet Service authentifié.

Remarque : Il n'est actuellement pas possible de définir un auteur personnalisé pour les posts. Tous les nouveaux posts apparaîtront comme s'ils avaient été créés par l'utilisateur actuellement authentifié.

Publier un article de blog

Vous pouvez utiliser la bibliothèque cliente .NET pour publier de nouvelles entrées de blog.

Commencez par créer un objet AtomEntry pour représenter l'article de blog. Vous pouvez ensuite définir le titre, le contenu et d'autres attributs de l'article de blog. Enfin, utilisez l'objet Service pour insérer le post. Voici un exemple de publication d'un nouvel article 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);

La méthode Insert utilise l'URL de publication du service comme paramètre. La méthode renvoie ensuite l'entrée telle qu'elle a été stockée par Blogger. L'entrée renvoyée est identique à celle que vous avez envoyée, mais elle contient également divers éléments ajoutés par Blogger, tels qu'un ID d'article.

Si, pour une raison quelconque, votre demande n'aboutit pas, Blogger peut renvoyer un code d'état différent. Pour en savoir plus sur les codes d'état, consultez le document de référence sur le protocole Google Data API.

Créer un brouillon d'article de blog

Les brouillons sont créés de la même manière que les posts publics, mais vous devez définir l'attribut draft de l'objet AtomEntry. Vous pouvez créer l'article de blog ci-dessus en tant que brouillon en ajoutant la ligne mise en surbrillance:

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);

Pour convertir un article de blog en brouillon publié, récupérez-le, définissez l'attribut "Brouillon" sur "false", puis mettez à jour l'article. Nous aborderons la récupération et la mise à jour des posts dans les deux sections suivantes.

Récupération des posts

Les sections suivantes expliquent comment récupérer la liste des articles de blog, avec et sans paramètres de requête.

Vous pouvez interroger un flux public Blogger sans authentification. Vous n'avez donc pas besoin de définir des identifiants ni d'effectuer une authentification AuthSub avant de récupérer des articles d'un blog public.

Récupération de tous les articles de blog

Pour récupérer les articles de l'utilisateur, appelez la même méthode getFeed que celle utilisée pour récupérer le métaflux des blogs, mais cette fois, envoyez l'URL du flux d'articles de 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);
}

Récupérer des posts à l'aide des paramètres de requête

L'API Data de Blogger vous permet de demander un ensemble d'entrées correspondant aux critères spécifiés, par exemple des articles de blog publiés ou mis à jour dans une plage de dates donnée. Pour ce faire, vous devez créer un objet FeedQuery et le transmettre à la méthode Service.Query().

Par exemple, pour envoyer une requête de plage de dates, définissez les membres MinPublication et MaxPublication de l'objet FeedQuery. L'extrait de code suivant imprime le titre de chaque article de blog publié entre l'heure de début et l'heure de fin indiquées:

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);
}

Notez que l'objet FeedQuery est construit avec la même URL de flux que celle utilisée pour récupérer les posts.

L'API Blogger Data accepte les paramètres de requête suivants:

alt: Type de flux à afficher, tel que atom (valeur par défaut) ou rss.
/category: Spécifiez des catégories (également appelées libellés) pour filtrer les résultats du flux. Par exemple, http://www.blogger.com/feeds/blogID/posts/default/-/Fritz/Laurie renvoie les entrées contenant les libellés Fritz et Laurie.
résultats max: Nombre maximal d'entrées à renvoyer.
commander: Ordre dans lequel les entrées doivent être affichées, par exemple lastmodified (valeur par défaut), starttime ou updated.
publié-min, publié-max: Limites liées aux dates de publication des entrées.
index de départ: Index de base 1 du premier résultat à récupérer (pour la pagination).
mis à jour, mis à jour, max.: Limites liées aux dates de mise à jour des entrées. Ces paramètres de requête sont ignorés, sauf si le paramètre orderby est défini sur updated.

Pour en savoir plus sur les paramètres de requête, consultez le guide de référence de l'API Blogger Data et le guide de référence des API Google Data.

Mise à jour des posts...

Pour mettre à jour un article de blog existant, commencez par récupérer l'entrée que vous souhaitez mettre à jour, puis modifiez-la avant de l'envoyer à Blogger à l'aide de la méthode Update() de l'entrée. L'extrait de code suivant modifie le titre d'une entrée de blog, en supposant que vous avez déjà récupéré l'entrée du serveur.

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;
}

Le code ci-dessus renvoie un AtomEntry contenant l'intégralité de l'article mis à jour. Pour mettre à jour d'autres propriétés, il vous suffit de les définir dans l'objet AtomEntry avant d'appeler Update().

Remarque: Il n'est actuellement pas possible de modifier les données d'auteur associées aux posts.

Suppression des posts

Pour supprimer un post, appelez la méthode Delete sur un objet AtomEntry existant, comme ceci:

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

Commentaires

L'API Blogger Data permet de créer, de récupérer et de supprimer des commentaires. Il n'est pas possible de mettre à jour les commentaires (ni dans l'interface Web).

Créer des commentaires

Pour publier un commentaire, créez un objet AtomEntry et insérez-le comme suit:

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);

Remarque: Actuellement, vous ne pouvez publier des commentaires que sur un blog appartenant à l'utilisateur authentifié.

Remarque: Il n'est actuellement pas possible de définir un auteur personnalisé pour les commentaires. Tous les nouveaux commentaires apparaîtront comme s'ils avaient été créés par l'utilisateur actuellement authentifié.

Récupération des commentaires...

Vous pouvez récupérer les commentaires d'un post donné à partir de l'URL du flux des commentaires du post:

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);
    }
  }
}

Vous pouvez également obtenir les commentaires de tous les articles en utilisant l'URL du flux de commentaires du blog:

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

Suppression des commentaires...

Pour supprimer un commentaire, appelez la méthode Delete() sur un objet de commentaire AtomEntry existant, comme suit:

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

Haut de page