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

Guide du développeur: Protocole

Important: Il s'agit d'une ancienne version de cette page. Pour obtenir la dernière version, utilisez les liens de la barre de navigation de gauche.

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

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

En plus de vous présenter les fonctionnalités de Blogger, Data API, ce document fournit des exemples d'interactions élémentaires de l'API Data à l'aide de XML et HTTP bruts. Après avoir lu ce document, vous voudrez peut-être en savoir plus sur interagissant avec l'API à l'aide de notre bibliothèques, consultez les sections spécifiques aux langages de programmation guide du développeur.

Sommaire

Audience

Ce document est destiné aux programmeurs qui souhaitent écrire des données des applications qui peuvent interagir avec Blogger via XML et HTTP.

Dans ce document, nous partons du principe que vous comprenez le concept général qui sous-tend les API Google Data protocole.

Si vous utilisez un système UNIX et que vous souhaitez essayer les exemples de ce document sans écrire de code, les utilitaires de ligne de commande UNIX curl ou wget peuvent vous être utiles. Pour en savoir plus, consultez les pages de manuel de ces utilitaires.

Pour en savoir plus sur l'API Blogger Data, consultez le Guide de référence du protocole.

Premiers pas

Création d'un compte Blogger

Vous pouvez vous inscrire à un Blogger à des fins de test. Blogger utilise un compte Google. Si vous possédez déjà un compte Google, vous êtes prêt.

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 nécessitent aucune authentification, mais sont en lecture seule. Si vous modifier des blogs, votre client doit s'authentifier avant de demander flux privés. Il peut utiliser l'une des deux approches suivantes: l'authentification par proxy AuthSub ou l'authentification par nom d'utilisateur/mot de passe ClientLogin.

Pour en savoir plus sur l'authentification avec les API Google Data en général, consultez la page Règles d'authentification documentation.

La plupart des exemples des sections suivantes de ce document supposent que vous fournissez l'authentification appropriée.

Authentification du proxy AuthSub

L'authentification par 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 client code n'a 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 au nom d'un utilisateur particulier. Pour en savoir plus, consultez la documentation AuthSub.

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

Les paramètres de requête suivants sont inclus dans l'URL 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 de champ d'application à utiliser est http://www.blogger.com/feeds/ (elle doit être encodée au format URL).
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'URL AuthSubRequest 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%2Fwelcome.html

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

Une fois l'utilisateur authentifié, 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, puisque Valeur du paramètre de requête token. Exemple :

http://www.example.com/welcome.html?token=yourAuthToken

Cette valeur de jeton représente un jeton AuthSub à usage unique. Dans cet exemple, comme session=1 a été spécifié, ce jeton peut être échangé contre un jeton de session AuthSub en appelant le service AuthSubSessionToken avec le jeton à usage unique dans un en-tête d'autorisation, comme suit :

GET /accounts/AuthSubSessionToken HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Authorization: AuthSub token="yourAuthToken"
User-Agent: Java/1.5.0_06
Host: www.google.com
Accept: text/html, image/gif, image/jpeg, *; q=.2, */*; q=.2
Connection: keep-alive

La réponse du service AuthSubSessionToken inclut un en-tête Token contenant le jeton de session et un en-tête Expiration indiquant la durée de validité du jeton.

Votre application peut ensuite utiliser la valeur du jeton de session dans En-tête Authorization des interactions ultérieures avec Blogger.

Voici un exemple de requête HTTP contenant un jeton non sécurisé pourrait envoyer à Blogger:

GET /feeds/blogID/blogs/posts/defaults HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Authorization: AuthSub token="yourSessionToken"
User-Agent: Java/1.5.0_06
Host: www.blogger.com
Accept: text/html, image/gif, image/jpeg, *; q=.2, */*; q=.2
Connection: keep-alive

Authentification par nom d'utilisateur/mot de passe ClientLogin

Utilisez l'authentification ClientLogin si votre client est un client autonome, "installé" et à un seul utilisateur (par exemple, une application de bureau). Pour demander un jeton d'authentification à l'aide du mécanisme ClientLogin, envoyez une requête POST à l'URL suivante :

https://www.google.com/accounts/ClientLogin

Le corps POST doit contenir un ensemble de paramètres de requête qui ressemblent à des paramètres transmis par un formulaire HTML, à l'aide du type de contenu application/x-www-form-urlencoded. Ces paramètres sont:

E-mail: Adresse e-mail de l'utilisateur.
Mot de passe: Mot de passe de l'utilisateur.
service: Le nom du service Blogger est blogger. (Pour les autres services consultez la liste des noms de service.)
accountType: Doit toujours être défini sur GOOGLE lorsque vous utilisez l'API Blogger. Si ce paramètre n'est pas défini, l'accès est bloqué pour les utilisateurs disposant également d'un compte G Suite.
source: Identifie votre application cliente. Doit se présenter sous la forme companyName-applicationName-versionID. Les exemples utilisent le nom exampleCo-exampleApp-1.

Pour plus d'informations sur ces paramètres, consultez la section Authentification pour Applications installées.

Si la requête d'authentification échoue, le serveur renvoie une réponse Code d'état 403 Forbidden.

Si l'opération réussit, le serveur renvoie l'état HTTP 200 OK. plus trois longs codes alphanumériques dans le corps de la réponse: SID, LSID, et Auth. La valeur Auth est le jeton d'autorisation que vous enverrez à Blogger avec chacune de vos requêtes ultérieures. Conservez donc une copie de cette valeur. Vous pouvez ignore les valeurs SID et LSID.

Étant donné que toutes les requêtes adressées à des flux privés nécessitent une authentification, vous devez définir l'en-tête "Authorization" dans toutes les interactions ultérieures avec Blogger, à l'aide de la méthode le format suivant:

Authorization: GoogleLogin auth=yourAuthToken

Où yourAuthToken correspond à la chaîne d'authentification renvoyée par la requête ClientLogin.

Pour en savoir plus sur l'authentification ClientLogin, y compris des exemples requêtes et les réponses correspondantes, consultez la section Authentification pour les Applications.

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

Remarque: Tel que décrit dans la méthode ClientLogin la demande d'authentification peut échouer et demander un CAPTCHA d'authentification. Si vous souhaitez que Google émette et gère le test CAPTCHA, redirigez l'utilisateur vers https://www.google.com/accounts/DisplayUnlockCaptcha?service=blogger (plutôt que vers l'URL de gestion du CAPTCHA indiquée dans la documentation ClientLogin).

Récupérer une liste de blogs

L'API Blogger Data fournit un flux qui liste les blogs d'un utilisateur donné. Ce flux est appelé "metaflux".

Envoyez un GET HTTP à l'URL suivante pour récupérer la liste des blogs :

http://www.blogger.com/feeds/userID/blogs

Remarque: Vous pouvez également remplacer default pour l'ID utilisateur, qui indique à Blogger de renvoyer la liste des les blogs de l'utilisateur dont les informations d'identification accompagnent la requête.

Une entrée dans le métaflux peut se présenter comme suit :

<entry>
  <id>tag:blogger.com,1999:blog-blogID.post-postID</id>
  <published>2006-08-02T18:44:43.089-07:00</published>
  <updated>2006-11-08T18:10:23.020-08:00</updated>
  <title type='text'>Lizzy's Diary</title>
  <summary type='html'>Being the journal of Elizabeth Bennet</summary>
  <link rel='alternate' type='text/html'
    href='http://blogName.blogspot.com/'>
  </link>
  <link rel='http://schemas.google.com/g/2005#feed'
    type='application/atom+xml'
    href='http://blogName.blogspot.com/feeds/posts/default'>
  </link>
  <link rel='http://schemas.google.com/g/2005#post'
    type='application/atom+xml'
    href='http://www.blogger.com/feeds/blogID/posts/default'>
  </link>
  <link rel='self' type='application/atom+xml'
    href='http://www.blogger.com/feeds/userID/blogs/blogID'>
  </link>
  <link rel='edit' type='application/atom+xml'
      href='http://www.blogger.com/feeds/userID/blogs/blogID'>
  </link>
  <author>
    <name>Elizabeth Bennet</name>
    <email>noreply@blogger.com</email>
    <uri>http://www.blogger.com/profile/profileID</uri>
  </author>
</entry>

Pour en savoir plus sur la signification de chacun de ces éléments, consultez les document de référence du protocole d'API de données ou le document Atom 1.0.

Si votre requête échoue pour une raison quelconque, Blogger peut renvoyer un code d'état différent. Pour en savoir plus sur les codes d'état HTTP, consultez également la documentation de référence sur le protocole des API Google Data.

Créer des posts

L'API Blogger Data vous permet de créer et de publier des articles de blog, ainsi que des brouillons d'articles.

Publication d'un article de blog

Après vous être authentifié, vous pouvez publier de nouvelles entrées de blog.

Commencez par créer une représentation XML du post à publier. Ce fichier XML doit se présenter sous la forme d'un élément Atom <entry>, qui peut se présenter comme suit :

<entry xmlns='http://www.w3.org/2005/Atom'>
  <title type='text'>Marriage!</title>
  <content type='xhtml'>
    <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>
  </content>
  <category scheme="http://www.blogger.com/atom/ns#" term="marriage" />
  <category scheme="http://www.blogger.com/atom/ns#" term="Mr. Darcy" />
</entry>

Remarque: Définir un auteur personnalisé pour les posts est n'est actuellement pas prise en charge. Tous les nouveaux posts apparaîtront comme s'ils avaient été créés par l'utilisateur actuellement authentifié.

Pour publier cette entrée, envoyez-la à l'URL de l'article du blog comme suit. Tout d'abord, placez votre élément <entry> Atom dans le corps d'une nouvelle requête POST à l'aide du type de contenu application/atom+xml. Recherchez ensuite l'URL de l'article de blog dans le métaflux à l'aide de la propriété Élément <link> où l'attribut rel se termine par #post L'URL de l'article du blog est indiquée comme attribut href de cet élément, qui se présente sous le format suivant :

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

Remarque: Cette URL est identique à l'URL du préfixe Balise <link rel="service.post"> figurant dans Section <head> de la version lisible par l'humain de la de notre blog.

Blogger crée un article de blog à partir de l'entrée que vous avez envoyée, puis renvoie une réponse le code d'état 201 CREATED, ainsi qu'une copie du nouveau post dans le forme d'un élément <entry>. L'entrée renvoyée est la même celui que vous avez envoyé, mais il contient également divers éléments ajoutés par Blogger, Élément <id>.

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

Créer un brouillon d'article de blog

Les brouillons sont créés de la même façon que les posts publics, mais avec une Un élément <app:control> a été ajouté à l'entrée pour indiquer que l'élément l'article ne doit pas (encore) être publié.

Cet élément <app:control> ne doit contenir qu'un seul <app:draft> en tant qu'enfant:

<app:control xmlns:app='http://purl.org/atom/app#'>
  <app:draft>yes</app:draft>
</app:control>

Les données contenues dans l'élément <app:draft> doivent être yes pour que le post soit reconnu comme brouillon.

Vous pouvez transformer un brouillon d'article de blog existant en article publié en récupérant le brouillon, en définissant les données de l'élément <app:draft> sur la chaîne no, puis en mettant à jour l'article. Récupérer et mettre à jour des posts est abordé dans les deux sections suivantes.

Remarque : Pour en savoir plus sur le protocole de publication Atom, y compris sur les espaces de noms <app:control> et <app:draft>, consultez la RFC 5023.

Récupérer des posts

Les sections suivantes décrivent comment récupérer une liste d'articles de blog, avec et sans paramètres de requête.

Vous pouvez interroger un flux public Blogger sans authentification. Par conséquent, vous vous n'avez pas besoin de définir le paramètre Authorization lorsque vous récupérez des articles de blog depuis un blog public.

Récupération de tous les articles de blog

Pour récupérer les posts de l'utilisateur, envoyez une requête HTTP GET au URL du flux du blog. Blogger renvoie ensuite un flux contenant les entrées de blog appropriées. Par exemple, pour obtenir la liste des articles de blog pour liz@gmail.com, envoyez la requête HTTP suivante à Blogger (en remplaçant blogID par la valeur appropriée, bien entendu) :

GET http://www.blogger.com/feeds/blogID/posts/default

Blogger renvoie ensuite un code d'état HTTP 200 OK et un flux Atom 1.0 standard contenant les articles de blog.

Voici un exemple de flux pour un blog contenant un seul article. Notez que nous avons légèrement modifié cet exemple pour le rendre un peu plus lisible par les humains. Plus spécifiquement, un flux Blogger réel contient des identifiants et des URL réels.

<feed xmlns='http://www.w3.org/2005/Atom'>
  <id>tag:blogger.com,1999:blog-blogID</id>
  <updated>2006-11-08T18:10:23.020-08:00</updated>
  <title type='text'>Lizzy's Diary</title>
  <link rel='alternate' type='text/html'
    href='http://blogName.blogspot.com/index.html'>
  </link>
  <link rel='http://schemas.google.com/g/2005#feed'
    type='application/atom+xml'
    href='http://blogName.blogspot.com/feeds/posts/default'>
  </link>
  <link rel='self' type='application/atom+xml'
    href='http://blogName.blogspot.com/feeds/posts/default'>
  </link>
  <author>
    <name>Elizabeth Bennet</name>
    <email>noreply@blogger.com</email>
    <uri>http://www.blogger.com/profile/profileID</uri>
  </author>
  <generator version='7.00' uri='http://www2.blogger.com'>Blogger</generator>
  <entry>
    <id>tag:blogger.com,1999:blog-blogID.post-postID</id>
    <published>2006-11-08T18:10:00.000-08:00</published>
    <updated>2006-11-08T18:10:14.954-08:00</updated>
    <title type='text'>Quite disagreeable</title>
    <content type='html'>&lt;p&gt;I met Mr. Bingley's friend Mr. Darcy
      this evening. I found him quite disagreeable.&lt;/p&gt;</content>
    <link rel='alternate' type='text/html'
      href='http://blogName.blogspot.com/2006/11/quite-disagreeable.html'>
    </link>
    <link rel='self' type='application/atom+xml'
      href='http://blogName.blogspot.com/feeds/posts/default/postID'>
    </link>
    <link rel='edit' type='application/atom+xml'
      href='http://www.blogger.com/feeds/blogID/posts/default/postID'>
    </link>
    <author>
      <name>Elizabeth Bennet</name>
      <email>noreply@blogger.com</email>
      <uri>http://www.blogger.com/profile/profileID</uri>
    </author>
  </entry>
</feed>

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

L'API Blogger Data vous permet de demander un ensemble d'entrées correspondant à des critères spécifiés, par exemple en demandant des articles de blog publiés ou mis à jour dans une plage de dates donnée.

Par exemple, pour envoyer une requête de plage de dates, ajoutez published-min et published-max à l'URL de la requête. Pour obtenir toutes les entrées de blog créées entre le 16 et le 24 mars 2008, envoyez une requête HTTP à l'URL du flux du blog :

GET http://www.blogger.com/feeds/blogID/posts/default?published-min=2008-03-16T00:00:00&published-max=2008-03-24T23:59:59

Lorsque vous envoyez cette requête GET, Blogger renvoie une réponse le code d'état 200 OK et un flux contenant tous les articles de blog qui ont été créé au cours de la période spécifiée.

Les paramètres updated-min et updated-max peuvent également pour obtenir la mise à jour de tous les articles du blog dans une plage donnée. Toutefois, notez que ces paramètres sont ignorés, sauf si le paramètre orderby est également défini sur updated.

L'API Blogger Data prend en charge les paramètres de requête suivants:

alt: Type de flux à renvoyer, tel que atom (par défaut) ou rss.
/category: Spécifie 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 des entrées avec les étiquettes Fritz et Laurie.
résultats-max: Nombre maximal d'entrées à renvoyer.
trier par: Ordre dans lequel les entrées doivent être renvoyées, par exemple lastmodified (par défaut), starttime ou updated.
publiée-min, publiée-max: Les limites des dates de publication des entrées.
start-index: Index en base 1 du premier résultat à récupérer (pour la pagination).
updated-min, updated-max: Les limites des 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, vous devez d'abord récupérer l'entrée que vous souhaitez avant de la modifier, puis d'envoyer une requête PUT avec l'entrée mise à jour dans le corps du message, à l'URL de modification du post. Assurez-vous que la Valeur <id> dans l'entrée à laquelle vous PUT correspond exactement la propriété <id> de l'entrée existante.

L'URL de modification est mise en surbrillance dans l'entrée suivante:

<entry>
  <id>tag:blogger.com,1999:blog-blogID.post-postID</id>
  <published>2006-11-08T18:10:00.000-08:00</published>
  <updated>2006-11-08T18:10:14.954-08:00</updated>
  <title type='text'>Quite disagreeable</title>
  <content type='html'>&lt;p&gt;I met Mr. Bingley's friend Mr. Darcy
    this evening. I found him quite disagreeable.&lt;/p&gt;</content>
  <link rel='alternate' type='text/html'
    href='http://blogName.blogspot.com/2006/11/quite-disagreeable.html'>
  </link>
  <link rel='self' type='application/atom+xml'
    href='http://blogName.blogspot.com/feeds/posts/default/postID'>
  </link>
  <link rel='edit' type='application/atom+xml'
    href='http://www.blogger.com/feeds/blogID/posts/default/postID'>
  </link>
  <category scheme="http://www.blogger.com/atom/ns#" term="Mr. Bingley" />
  <category scheme="http://www.blogger.com/atom/ns#" term="Mr. Darcy" />
  <author>
    <name>Elizabeth Bennet</name>
    <email>noreply@blogger.com</email>
    <uri>http://www.blogger.com/profile/profileID</uri>
  </author>
</entry>

IMPORTANT: Pour garantir la rétrocompatibilité, veillez à que lorsque vous PUT une entrée mise à jour, vous conservez tout le fichier XML qui était présent lorsque vous avez récupéré l'entrée de Blogger. Sinon, lorsque nous implémentons de nouveaux éléments et incluons des éléments <new-awesome-feature> dans le flux, votre client ne les renverra pas et vos utilisateurs ne les verront pas. L'application Google Les bibliothèques clientes de l'API Data gèrent cette opération correctement. Par conséquent, si vous utilisez l’une des bibliothèques que vous avez terminés.

Remarque: Modifier les données d'auteur associées à posts n'est pas pris en charge pour le moment.

Conseil de dépannage : Certains pare-feu bloquent les messages HTTP PUT. Pour contourner ce problème, vous pouvez inclure un en-tête X-HTTP-Method-Override: PUT dans une requête POST. Pour plus d'informations, reportez-vous à la documentation Google Data API les principes de base du protocole.

Supprimer des posts

Pour supprimer un post, envoyez une requête DELETE à l'URL de modification du post. Il s'agit de la même URL que celle utilisée pour modifier des posts.

Conseil de dépannage: Certains pare-feu bloquent les connexions HTTP DELETE messages. Pour contourner ce problème, vous pouvez inclure un en-tête X-HTTP-Method-Override: DELETE dans une requête POST. Pour plus d'informations, reportez-vous à la documentation Google Data API les principes de base du protocole.

Commentaires

L'API Blogger Data permet de créer, de récupérer et de supprimer des commentaires. La modification des commentaires n'est pas possible (et n'est pas disponible dans l'interface Web).

Création de commentaires

Pour publier un commentaire, créez un élément Atom <entry>, comme suivantes:

  <entry xmlns='http://www.w3.org/2005/Atom'>
    <title type="text">This is my first comment</title>
    <content type="html">This is my first comment</content>
  </entry>

Pour publier ce commentaire, placez votre élément Atom <entry> dans le corps d'une nouvelle requête POST, à l'aide de la méthode Type de contenu application/atom+xml. Ensuite, envoyez POST à l'URL Blogger appropriée:

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

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

Remarque: Définir un auteur personnalisé pour les commentaires est n'est actuellement pas prise en charge. Tous les nouveaux commentaires apparaîtront comme s'ils avaient été créés par l'utilisateur actuellement authentifié.

Récupérer des commentaires

Vous pouvez récupérer les commentaires d'un post particulier en envoyant une GET à l'URL du flux de commentaires de cet article:

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

Vous pouvez également récupérer les commentaires de tous les messages en utilisant le flux de commentaires du blog. URL:

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

Ces requêtes renvoient un flux de commentaires qui se présente comme suit:

<feed xmlns="http://www.w3.org/2005/Atom" xmlns:openSearch="http://a9.com/-/spec/opensearchrss/1.0/"
         xmlns:thr="http://purl.org/syndication/thread/1.0">
  <id>tag:blogger.com,1999:blog-blogID.post-postID.comment-commentID</id>
  <updated>2007-04-04T21:56:29.803-07:00</updated>
  <title type="text">My Blog : Time to relax</title>
  <link rel="alternate" type="text/html" href="http://blogName.blogspot.com/2007/04/first-post.html"/>
  <link rel="http://schemas.google.com/g/2005#feed" type="application/atom+xml" href="http://blogName.blogspot.com/feeds/postID/comments/default"/>
  <link rel="self" type="application/atom+xml" href="http://blogName.blogspot.com/feeds/postID/comments/default"/>
  <author>
    <name>Blog Author name</name>
  </author>
  <generator version="7.00" uri="http://www2.blogger.com">Blogger</generator>
  <openSearch:totalResults>1</openSearch:totalResults>
  <openSearch:startIndex>1</openSearch:startIndex>
  <entry>
    <id>tag:blogger.com,1999:blog-blogID.post-commentID</id>
    <published>2007-04-04T21:56:00.000-07:00</published>
    <updated>2007-04-04T21:56:29.803-07:00</updated>
    <title type="text">This is my first comment</title>
    <content type="html">This is my first comment</content>
    <link rel="alternate" type="text/html" href="http://blogName.blogspot.com/2007/04/first-post.html#commentID"/>
    <link rel="self" type="application/atom+xml" href="http://blogName.blogspot.com/feeds/postID/comments/default/commentID"/>
    <link rel="edit" type="application/atom+xml" href="http://www.blogger.com/feeds/blogID/postID/comments/default/commentID"/>
    <thr:in-reply-to href="http://blogName.blogspot.com/2007/04/first-post.html" 
                     ref="tag:blogger.com,1999:blog-blogID.post-postID" 
                     source="http://www.blogger.com/feeds/posts/default/blogID"
                     type="text/html"/>
    <author>
      <name>Blog Author name</name>
      <email>blog_author@gmail.com</email>
      <uri>http://www.blogger.com/profile/userID</uri>
    </author>
    <thr:in-reply-to xmlns:thr='http://purl.org/syndication/thread/1.0' 
         href='http://blogName.blogspot.com/2007/04/first-post.html' 
         ref='tag:blogger.com,1999:blog-blogID.post-postID' 
         source='http://blogName.blogspot.com/feeds/posts/default/postID'
         type='text/html' />
  </entry>
</feed>

Suppression des commentaires

Pour supprimer un commentaire, envoyez une requête DELETE à l'URL de modification du commentaire. Cette URL est mise en surbrillance dans le flux de commentaires ci-dessus.

Format d'exportation

Blogger permet aux utilisateurs d'exporter et d'importer leurs blogs à l'aide d'un fichier d'exportation Blogger. Ce fichier d'exportation contient tous les articles et commentaires d'un blog. Le format du fichier d'exportation est exactement le même format Atom que celui décrit dans les sections sur la récupération des posts et des commentaires. Ce fichier d'exportation contiendra Contenu du flux d'articles et du flux de commentaires combinés dans un seul document.

Pour exporter ou importer des données de blog à l'aide du format d'exportation, accédez à la page Paramètres du blog. Pour récupérer le fichier d'exportation d'un à l'aide de l'API Data, utilisez l'URL suivante:

GET http://www.blogger.com/feeds/blogID/archive

Pour importer le fichier d'exportation, créez une requête POST à l'URL suivante en utilisant le contenu du fichier d'exportation comme données de requête et application/atom+xml comme type de contenu :

POST http://www.blogger.com/feeds/blogID/archive/full

Aucune des URL ci-dessus n'est compatible avec les paramètres de requête. Les deux requêtes doivent contiennent également des informations d'authentification et ne les administrateurs du blog pourront l'importer/exporter à l'aide de ces flux URL.

Remarque: Si vous créez votre propre blog Blogger, fichier d'exportation, l'ordre des publications est actuellement limité et les entrées de commentaires. Le fichier d'exportation Blogger liste tous les articles en premier, et tous les commentaires. Vous pouvez entrelacer les entrées de posts et de commentaires du moment que l'entrée du commentaire s'affiche après le post auquel le commentaire est destiné.

Pour en savoir plus sur la façon dont Blogger utilise le format Atom dans le fichier d'exportation, consultez le guide de référence du protocole.

Haut de page