Guide du langage Java

Important : Ce document a été rédigé avant 2012. Les options d'authentification décrites dans ce document (OAuth 1.0, AuthSub et ClientLogin) ont été officiellement abandonnées le 20 avril 2012 et ne sont plus disponibles. Nous vous encourageons à migrer vers OAuth 2.0 dès que possible.

L'API Google Sites Data permet aux applications clientes d'accéder au contenu d'un site Google, de le publier et de le modifier. Votre application cliente peut également demander une liste des activités récentes, récupérer l'historique des révisions et télécharger des pièces jointes.

En plus de fournir des informations générales sur les fonctionnalités de l'API Sites Data, ce guide fournit des exemples d'interaction avec l'API à l'aide de la bibliothèque cliente Java. Pour obtenir de l'aide sur la configuration de la bibliothèque cliente, consultez Premiers pas avec la bibliothèque cliente Java Google Data. Si vous souhaitez en savoir plus sur le protocole sous-jacent utilisé par la bibliothèque cliente Java pour interagir avec l'ancienne API Sites, consultez le guide du protocole.

Audience

Ce document est destiné aux développeurs qui souhaitent écrire des applications clientes interagissant avec Google Sites à l'aide de la bibliothèque cliente Google Data pour Java.

Premiers pas

Google Sites utilise des comptes Google ou G Suite pour l'authentification. Si vous avez déjà un compte, vous n'avez rien à faire. Sinon, vous pouvez créer un autre compte.

Installer la bibliothèque

Pour obtenir de l'aide concernant la configuration et l'installation de la bibliothèque cliente, consultez Premiers pas avec la bibliothèque cliente Java Google Data. Si vous utilisez Eclipse, cet article explique également comment configurer votre projet à l'aide du plug-in Eclipse pour les API Google Data. Pour commencer, voici ce dont vous avez besoin :

1. Installer Java 1.5 ou version ultérieure
2. Téléchargez la bibliothèque cliente (dernière version de gdata-src.java.zip).
3. Télécharger la liste des dépendances
4. Téléchargez les exemples d'applications (la dernière version de gdata-samples.java.zip).

Après avoir installé les fichiers .jar, vous devez inclure les éléments suivants dans votre projet :

1. java/lib/gdata-sites-2.0.jar : la version 2.0 ici est destinée à la version 1.4 de l'ancienne API Sites.
2. java/lib/gdata-core-1.0.jar
3. java/lib/gdata-client-1.0.jar
4. java/lib/gdata-spreadsheet-3.0.jar (si vous travaillez avec des pages de liste / des éléments de liste)

Veillez également à inclure les fichiers JAR de dépendance (gdata-media-1.0.jar, mail.jar et google-collect....jar).

Exécuter l'exemple d'application

Un exemple d'application fonctionnel complet se trouve dans le sous-répertoire /java/sample/sites du téléchargement gdata-samples.java.zip. La source est également disponible dans /trunk/java/sample/sites/ du dépôt SVN accessible depuis l'onglet "Source". SitesDemo.java permet à l'utilisateur d'effectuer un certain nombre d'opérations qui montrent comment utiliser l'API Sites classique.

Notez que vous devrez inclure java/sample/util/lib/sample-util.jar pour exécuter l'exemple.

Démarrer votre propre projet

Conseil : Consultez l'article Utiliser Eclipse avec les API Google Data pour une configuration rapide avec notre plug-in Eclipse.

Selon les besoins de votre application, vous aurez besoin de plusieurs importations. Nous vous recommandons de commencer par les importations suivantes :

import com.google.gdata.client.*;
import com.google.gdata.client.sites.*;
import com.google.gdata.data.*;
import com.google.gdata.data.acl.*;
import com.google.gdata.data.media.*;
import com.google.gdata.data.sites.*;
import com.google.gdata.data.spreadsheet.*;  // If working with listpages / listitems
import com.google.gdata.util.*;

Vous devrez ensuite configurer un objet SitesService, qui représente une connexion client à l'ancienne API Sites :

SitesService client = new SitesService("yourCo-yourAppName-v1");

L'argument applicationName doit respecter le format suivant : company-applicationname-version. Ce paramètre est utilisé à des fins de journalisation.

Remarque : Le reste de ce guide part du principe que vous avez créé un SitesService dans la variable client.

S'authentifier dans l'API Sites pour la version classique

La bibliothèque cliente Java peut être utilisée avec des flux publics ou privés. L'API Sites Data permet d'accéder aux flux privés et publics, en fonction des autorisations Sites et de l'opération que vous essayez d'effectuer. Par exemple, vous pouvez lire le flux de contenu d'un site public, mais pas le modifier. Pour cela, vous auriez besoin d'un client authentifié. Cela peut être fait via l'authentification par nom d'utilisateur/mot de passe ClientLogin, AuthSub ou OAuth.

Pour en savoir plus sur AuthSub, OAuth et ClientLogin, consultez la présentation de l'authentification des API Google Data.

Remarque : L'API est compatible avec SSL (HTTPS). Si vous utilisez AuthSub/OAuth, veillez à spécifier un champ d'application https://sites.google.com/feeds/ pour demander des flux via SSL. Notez également que, pour les domaines G Suite, le paramètre "Exiger SSL" du panneau de configuration de l'administrateur est respecté par l'API. Vous pouvez forcer toutes les requêtes API à utiliser HTTPS en appelant client.useSsl();.

AuthSub pour les applications Web

L'authentification AuthSub pour les applications Web doit être utilisée par les applications clientes qui doivent authentifier leurs utilisateurs auprès des comptes Google. L'opérateur n'a pas besoin d'accéder au nom d'utilisateur et au mot de passe de l'utilisateur Google Sites. Seul un jeton AuthSub est requis.

import com.google.gdata.client.*;

String nextUrl = "http://www.example.com/welcome.jsp";
String scope = "https://sites.google.com/feeds/";
boolean secure = true;
boolean session = true;
String authSubUrl = AuthSubUtil.getRequestUrl(nextUrl, scope, secure, session);

import com.google.gdata.client.*;

String hostedDomain = "example.com";
String nextUrl = "http://www.example.com/welcome.jsp";
String scope = "https://sites.google.com/feeds/";  // SSL is also supported
boolean secure = true;
boolean session = true;
String authSubUrl = AuthSubUtil.getRequestUrl(hostedDomain, nextUrl, scope, secure, session);

OAuth pour les applications Web ou installées/mobiles

OAuth peut être utilisé comme alternative à AuthSub et est destiné aux applications Web. OAuth est semblable au mode sécurisé et enregistré d'AuthSub, car toutes les demandes de données doivent être signées numériquement et vous devez enregistrer votre domaine.

ClientLogin pour les applications installées/mobiles

ClientLogin doit être utilisé par les applications installées ou mobiles qui doivent authentifier leurs utilisateurs auprès des comptes Google. Lors de la première exécution, votre application invite l'utilisateur à saisir son nom d'utilisateur et son mot de passe. Un jeton d'authentification est référencé dans les requêtes suivantes.

SitesService client = new SitesService("yourCo-yourAppName-v1");
client.setUserCredentials("example@gmail.com", "pa$$word");

Haut de page

Flux de site

Le flux de sites peut être utilisé pour lister les sites Google Sites dont un utilisateur est propriétaire ou pour lesquels il dispose d'autorisations d'affichage. Il peut également être utilisé pour modifier le nom d'un site existant. Pour les domaines G Suite, il peut également être utilisé pour créer et/ou copier un site entier.

Répertorier les sites

Pour interroger le flux de site, envoyez une requête HTTP GET à l'URL du flux de site :

https://sites.google.com/feeds/site/site/

Dans le client Java, vous pouvez utiliser les classes SiteFeed et SiteEntry pour travailler avec le flux de site :

public String getSiteFeedUrl() {
  String domain = "site";  // OR if the Site is hosted on G Suite, your domain (e.g. example.com)
  return "https://sites.google.com/feeds/site/" + domain + "/";
}

public void getSiteFeed() throws IOException, ServiceException {
  SiteFeed siteFeed = client.getFeed(new URL(getSiteFeedUrl()), SiteFeed.class);
  for (SiteEntry entry : siteFeed.getEntries()){
    System.out.println("title: " + entry.getTitle().getPlainText());
    System.out.println("site name: " + entry.getSiteName().getValue());
    System.out.println("theme: " + entry.getTheme().getValue());
    System.out.println("");
  }
}

L'extrait de code ci-dessus affiche le titre du site, son nom et son thème. D'autres getters sont disponibles pour accéder à des propriétés supplémentaires dans le flux.

Créer des sites

Remarque : Cette fonctionnalité n'est disponible que pour les domaines G Suite.

Pour provisionner des sites, créez un SiteEntry et appelez la méthode insert() du client sur le flux de sites.

Cet exemple crée un site avec le thème "slate" (paramètre facultatif) et fournit le nom du site (obligatoire) et la description (facultative) :

public String getSiteFeedUrl() {
  String domain = "example.com";
  return "https://sites.google.com/feeds/site/" + domain + "/";
}

public SiteEntry createSite(String title, String summary, String theme, String tag)
    throws MalformedURLException, IOException, ServiceException {
  SiteEntry entry = new SiteEntry();
  entry.setTitle(new PlainTextConstruct(title));
  entry.setSummary(new PlainTextConstruct(summary));

  Theme tt = new Theme();
  tt.setValue(theme);
  entry.setTheme(tt);

  entry.getCategories().add(new Category(TagCategory.Scheme.TAG, tag, null));

  return client.insert(new URL(getSiteFeedUrl()), entry);
}

SiteEntry newSiteEntry = createSite("My Site Title", "summary for site", "slate", "tag");

La requête ci-dessus permet de créer un site sous le domaine G Suite example.com. L'URL du site serait donc https://sites.google.com/a/example.com/my-site-title.

Si le site est créé, le serveur répond avec un objet SiteEntry, rempli avec les éléments ajoutés par le serveur : un lien vers le site, un lien vers le flux ACL du site, le nom du site, le titre, le résumé, etc.

Copier un site

Remarque : Cette fonctionnalité n'est disponible que pour les domaines G Suite.

Copier un site revient à en créer un. La différence est que vous devez définir un lien sur votre nouveau SiteEntry qui inclut le lien vers le site à dupliquer. Voici un exemple de duplication du site créé dans la section Créer des sites :

public SiteEntry copySite(String title, String summary, String sourceHref)
    throws MalformedURLException, IOException, ServiceException {
  SiteEntry entry = new SiteEntry();
  entry.setTitle(new PlainTextConstruct(title));
  entry.setSummary(new PlainTextConstruct(summary));
  entry.addLink(SitesLink.Rel.SOURCE, Link.Type.ATOM, sourceHref);

  return client.insert(new URL(getSiteFeedUrl()), entry);
}

String sourceHref = newSiteEntry.getLink(SitesLink.Rel.SOURCE, Link.Type.ATOM).getHref();
SiteEntry myTwin = copySite("Duplicate Site", "A copy", sourceHref);

Points importants :

• Seuls les sites et les modèles de site appartenant à l'utilisateur authentifié peuvent être copiés.
• Vous pouvez également copier un modèle de site. Un site est un modèle si le paramètre "Publier ce site comme modèle" est coché sur la page des paramètres Google Sites.
• Vous pouvez copier un site depuis un autre domaine, à condition d'être listé comme propriétaire sur le site source.

Mettre à jour les métadonnées d'un site

Pour renommer un site, modifier son thème, son tag de catégorie ou son résumé, vous devez d'abord récupérer SiteEntry contenant le site en question, modifier une ou plusieurs propriétés, puis appeler la méthode update() de SiteEntry. Cet exemple modifie le thème du site précédent et le renomme :

myTwin.setTitle(new PlainTextConstruct("better-title"));

Theme theme = myTwin.getTheme();
theme.setValue('iceberg');
myTwin.setTheme(theme);

myTwin.getCategories().add(new Category(TagCategory.Scheme.TAG, "newTag", null));

SiteEntry updatedSiteEntry = myTwin.update();

System.out.println(updatedSiteEntry.getTitle().getPlainText();

Mappages d'adresses Web

Les mappages d'adresses Web permettent aux utilisateurs de Sites d'associer leurs propres domaines à un site Google. Par exemple, http://www.mydomainsite.com peut être utilisé à la place de http://sites.google.com/a/domain.com/mysite. Selon l'endroit où votre site est hébergé, vous pouvez modifier manuellement les mappages d'adresses Web d'un site. Pour en savoir plus, consultez cet article du Centre d'aide.

Récupérer les mappages d'adresses Web d'un site

Pour renvoyer les mappages d'adresses Web d'un site, récupérez l'entrée/le flux du site avec le paramètre with-mappings=true :

SiteQuery query = new SiteQuery(new URL("https://sites.google.com/feeds/site/siteName"));
query.setWithMappings(true);

SiteFeed feed = service.getFeed(query, SiteFeed.class);
for (SiteEntry entry : feed.getEntries()) {
  System.out.println("Mappings for '" + entry.getSiteName().getValue() + "':");
  for (Link link : entry.getWebAddressMappingLinks()) {
    System.out.println("  " + link.getHref());
  }
}

Les mappages existants s'affichent sous forme de link avec rel="webAddressMapping". Par exemple, dans l'exemple ci-dessus, il existe trois webAddressMapping qui pointent vers le site http://sites.google.com/site/myOtherTestSite.

Modifier les mappages d'adresses Web

Remarque : Toutes les opérations GET/POST/PUT doivent spécifier le paramètre with-mappings=true lorsque vous travaillez avec des mappages d'adresses Web. Si le paramètre est absent, webAddressMapping ne sera pas renvoyé dans les entrées de site (GET) ni pris en compte lors de la mise à jour/suppression (PUT) des mappages d'une entrée.

Pour ajouter, modifier ou supprimer un mappage, il vous suffit de spécifier, de modifier ou de supprimer un tel lien lorsque vous créez des sites ou mettez à jour les métadonnées d'un site. Le paramètre with-mappings=true doit être inclus dans l'URI du flux du site. Remarque : Pour mettre à jour les mappages d'adresses, vous devez être administrateur du site ou administrateur du domaine dans le cas d'un site hébergé dans G Suite.

Par exemple, la requête ci-dessous met à jour le mappage http://www.mysitemapping.com sur http://www.my-new-sitemapping.com et supprime http://www.mysitemapping2.com en omettant le lien dans l'entrée :

SiteEntry entry = client.getEntry(new URL("https://sites.google.com/feeds/site/site/siteName?with-mappings=true"), SiteEntry.class);

// Modify mappings (remove all mappings, add some of them again, add modified mappings)
entry.removeLinks(SitesLink.Rel.WEBADDRESSMAPPING, Link.Type.HTML);
entry.addLink(SitesLink.Rel.WEBADDRESSMAPPING, Link.Type.HTML, "http://www.my-new-sitemapping.com");

// Update the entry with the mappings.
entry.update();

Notez que vous pouvez également spécifier des mappages d'adresses Web lorsque vous créez ou copiez un site.

Haut de page

Flux d'activités

Vous pouvez récupérer l'activité récente (modifications) d'un site en récupérant le flux d'activité. Chaque entrée du flux d'activité contient des informations sur une modification apportée au site.

Pour interroger le flux d'activité, envoyez une requête HTTP GET à l'URL du flux d'activité :

https://sites.google.com/feeds/activity/site/siteName

Dans le client Java, utilisez la classe ActivityFeed pour renvoyer des objets ActivityEntry :

public String buildActivityFeedUrl() {
  String domain = "site";  // OR if the Site is hosted on G Suite, your domain (e.g. example.com)
  String siteName = "mySite";
  return "https://sites.google.com/feeds/activity/" + domain + "/" + siteName + "/";
}

public void getActivityFeed() throws IOException, ServiceException {
  ActivityFeed activityFeed = client.getFeed(new URL(buildActivityFeedUrl()), ActivityFeed.class);
  for (BaseActivityEntry<?> entry : activityFeed.getEntries()){
    System.out.println(entry.getSummary().getPlainText());
    System.out.println(" revisions link: " + entry.getRevisionLink().getHref());
  }
}

Remarque : Pour accéder à ce flux, vous devez être collaborateur ou propriétaire du site. Votre client doit s'authentifier à l'aide d'un jeton AuthSub, OAuth ou ClientLogin. Consultez S'authentifier auprès du service Sites.

Haut de page

Flux de révisions

Pour récupérer l'historique des révisions d'une entrée de contenu, envoyez une requête HTTP GET au lien de révision de l'entrée :

https://sites.google.com/feeds/revision/site/siteName/CONTENT_ENTRY_ID

Cet exemple interroge le flux de contenu, puis récupère le flux de révisions pour la première entrée de contenu :

ContentFeed contentFeed = client.getFeed(new URL(buildContentFeedUrl()), ContentFeed.class);
URL revisionFeedUrl = new URL(contentFeed.getEntries().get(0).getRevisionLink().getHref()); // use first entry

public void getRevisionFeed(String revisionFeedUrl) throws IOException, ServiceException {
  RevisionFeed revisionFeed = client.getFeed(revisionFeedUrl, RevisionFeed.class);
  for (BaseContentEntry<?> entry : revisionFeed.getEntries()){
    System.out.println(entry.getTitle().getPlainText());
    System.out.println(" updated: " + entry.getUpdated().toUiString() + " by " +
        entry.getAuthors().get(0).getEmail());
    System.out.println(" revision #: " + entry.getRevision().getValue());
  }
}

Remarque : Pour accéder à ce flux, vous devez être collaborateur ou propriétaire du site. Votre client doit s'authentifier à l'aide d'un jeton AuthSub, OAuth ou ClientLogin. Consultez S'authentifier auprès du service Sites.

Haut de page

Flux de contenu

Récupérer le flux de contenu

Le flux de contenu liste les derniers contenus d'un site. Vous pouvez y accéder en envoyant un GET HTTP à l'URL du flux de contenu :

https://sites.google.com/feeds/content/site/siteName

Exemple de récupération du flux de contenu :

public String buildContentFeedUrl() {
  String domain = "site";  // OR if the Site is hosted on G Suite, your domain (e.g. example.com)
  String siteName = "mySite";
  return "https://sites.google.com/feeds/content/" + domain + "/" + siteName + "/";
}

ContentFeed contentFeed = client.getFeed(new URL(buildContentFeedUrl()), ContentFeed.class);

Le contentFeed obtenu est un objet ContentFeed contenant la réponse du serveur. Chaque entrée de contentFeed représente une page ou un élément différent du site de l'utilisateur. ContentFeed contient différents types d'objets, tous hérités de BaseContentEntry : ListItemEntry, ListPageEntry, AttachmentEntry, WebAttachmentEntry, FileCabinetPageEntry, AnnouncementsPageEntry, AnnouncementEntry, WebPageEntry, CommentEntry.

Voici un exemple de liste des différents types d'entrées dans un ContentFeed. Chaque type d'entrée contient différentes propriétés, mais elles ne sont pas toutes indiquées ici.

public String getContentBlob(BaseContentEntry<?> entry) {
 return ((XhtmlTextConstruct) entry.getTextContent().getContent()).getXhtml().getBlob();
}

// Extracts an entry's numeric ID.
private String getEntryId(String selfLink) {
  return selfLink.substring(selfLink.lastIndexOf("/") + 1);
}

public void printContentEntries(ContentFeed contentFeed) {
  System.out.println("Listing all WebPageEntry:");
  for (WebPageEntry entry : contentFeed.getEntries(WebPageEntry.class)) {
    System.out.println(" title: " + entry.getTitle().getPlainText());
    System.out.println(" id: " + getEntryId(entry));
    if (entry.getParentLink() != null) {
      System.out.println(" parent id: " + getEntryId(entry.getParentLink().getHref()));
    }
    System.out.println(" author: " + entry.getAuthors().get(0).getEmail());
    System.out.println(" content: " + getContentBlob(entry));
  }

  System.out.println("Listing all ListPageEntry:");
  for (ListPageEntry entry : contentFeed.getEntries(ListPageEntry.class)) {
    System.out.println(" title: " + entry.getTitle().getPlainText());
    System.out.println(" id: " + getEntryId(entry));
    for (Column col : entry.getData().getColumns()) {
      System.out.print(" [" + col.getIndex() + "] " + col.getName() + "\t");
    }
  }

  for (ListItemEntry entry : contentFeed.getEntries(ListItemEntry.class)) {
    for (Field field : entry.getFields()) {
      System.out.print(" [" + field.getIndex() + "] " + field.getValue() + "\t");
    }
    System.out.println("\n");
  }

  System.out.println("Listing all FileCabinetPageEntry:");
  for (FileCabinetPageEntry entry : contentFeed.getEntries(FileCabinetPageEntry.class)) {
    System.out.println(" title: " + entry.getTitle().getPlainText());
    System.out.println(" id: " + getEntryId(entry));
    System.out.println(" content: " + getContentBlob(entry));
  }

  System.out.println("Listing all CommentEntry:");
  for (CommentEntry entry : contentFeed.getEntries(CommentEntry.class)) {
    System.out.println(" in-reply-to: " + entry.getInReplyTo().toString());
    System.out.println(" content: " + getContentBlob(entry));
  }

  System.out.println("Listing all AnnouncementsPageEntry:");
  for (AnnouncementsPageEntry entry : contentFeed.getEntries(AnnouncementsPageEntry.class)) {
    System.out.println(" title: " + entry.getTitle().getPlainText());
    System.out.println(" id: " + getEntryId(entry));
    System.out.println(" content: " + getContentBlob(entry));
  }

  System.out.println("Listing all AnnouncementEntry:");
  for (AnnouncementEntry entry : contentFeed.getEntries(AnnouncementEntry.class)) {
    System.out.println(" title: " + entry.getTitle().getPlainText());
    System.out.println(" id: " + getEntryId(entry));
    if (entry.getParentLink() != null) {
      System.out.println(" parent id: " + getEntryId(entry.getParentLink().getHref()));
    }
    System.out.println(" draft?: " + entry.isDraft());
    System.out.println(" content: " + getContentBlob(entry));
  }

  System.out.println("Listing all AttachmentEntry:");
  for (AttachmentEntry entry : contentFeed.getEntries(AttachmentEntry.class)) {
    System.out.println(" title: " + entry.getTitle().getPlainText());
    System.out.println(" id: " + getEntryId(entry));
    if (entry.getParentLink() != null) {
      System.out.println(" parent id: " + getEntryId(entry.getParentLink().getHref()));
    }
    if (entry.getSummary() != null) {
      System.out.println(" description: " + entry.getSummary().getPlainText());
    }
    System.out.println(" revision: " + entry.getRevision().getValue());
    MediaContent content = (MediaContent) entry.getContent();
    System.out.println(" src: " + content.getUri());
    System.out.println(" content type: " + content.getMimeType().getMediaType());
  }

  System.out.println("Listing all WebAttachmentEntry:");
  for (WebAttachmentEntry entry : contentFeed.getEntries(WebAttachmentEntry.class)) {
    System.out.println(" title: " + entry.getTitle().getPlainText());
    System.out.println(" id: " + getEntryId(entry));
    if (entry.getParentLink() != null) {
      System.out.println(" parent id: " + getEntryId(entry.getParentLink().getHref()));
    }
    if (entry.getSummary() != null) {
      System.out.println(" description: " + entry.getSummary().getPlainText());
    }
    System.out.println(" src: " + ((MediaContent) entry.getContent()).getUri());
  }
}

Remarque : L'authentification peut être requise ou non pour ce flux, en fonction des autorisations de partage du site. Si le site n'est pas public, votre client doit s'authentifier à l'aide d'un jeton AuthSub, OAuth ou ClientLogin. Consultez S'authentifier auprès du service Sites.

Exemples de requêtes de flux de contenu

Vous pouvez effectuer une recherche dans le flux de contenu à l'aide de certains paramètres de requête standards de l'API Google Data et de ceux spécifiques à l'ancienne API Sites. Pour en savoir plus et obtenir la liste complète des paramètres acceptés, consultez le Guide de référence.

Remarque : Les exemples de cette section utilisent la méthode buildContentFeedUrl() dans Récupérer le flux de contenu.

Récupérer des types d'entrées spécifiques

Pour n'extraire qu'un type d'entrée particulier, utilisez le paramètre kind. Cet exemple ne renvoie que les entrées attachment :

ContentQuery query = new ContentQuery(new URL(buildContentFeedUrl()));
query.setKind("webpage");
ContentFeed contentFeed = client.getFeed(query, ContentFeed.class);
for (AttachmentEntry entry : contentFeed.getEntries(AttachmentEntry.class)) {
  System.out.println(entry.getTitle().getPlainText());
}

Pour renvoyer plusieurs types d'entrées, séparez chaque kind par une virgule (","). Cet exemple renvoie les entrées filecabinet et listpage :

URL url = new URL(buildContentFeedUrl() + "?kind=filecabinet,listpage");
ContentFeed contentFeed = client.getFeed(url, ContentFeed.class);
for (FileCabinetPageEntry entry : contentFeed.getEntries(FileCabinetPageEntry.class)) {
  System.out.println(" title: " + entry.getTitle().getPlainText());
}
for (ListPageEntry entry : contentFeed.getEntries(ListPageEntry.class)) {
  System.out.println(" title: " + entry.getTitle().getPlainText());
}

Récupérer une page par chemin d'accès

Si vous connaissez le chemin relatif d'une page dans le site Google, vous pouvez utiliser le paramètre path pour récupérer cette page spécifique. Cet exemple renverrait la page située à l'adresse http://sites.google.com/site/siteName/path/to/the/page :

ContentQuery query = new ContentQuery(new URL(buildContentFeedUrl()));
query.setPath("/path/to/the/page");
ContentFeed contentFeed = client.getFeed(query, ContentFeed.class);
for (BaseContentEntry<?> entry : contentFeed.getEntries()) {
  System.out.println(" title: " + entry.getTitle().getPlainText());
}

Récupérer toutes les entrées d'une page parente

Si vous connaissez l'ID d'entrée de contenu d'une page (par exemple, "1234567890" dans l'exemple ci-dessous), vous pouvez utiliser le paramètre parent pour récupérer toutes ses entrées enfants (le cas échéant) :

ContentQuery query = new ContentQuery(new URL(buildContentFeedUrl()));
query.setParent("1234567890");
ContentFeed contentFeed = client.getFeed(query, ContentFeed.class);

Pour connaître les autres paramètres, consultez le guide de référence.

Haut de page

Créer du contenu

Remarque : Avant de créer du contenu pour un site, assurez-vous d'avoir défini votre site dans le client.
client.site = "siteName";

Pour créer du contenu (pages Web, pages de liste, pages de dépôt de fichiers, pages d'annonces, etc.), envoyez une requête HTTP POST au flux de contenu :

https://sites.google.com/feeds/content/site/siteName

Pour obtenir la liste des types de nœuds compatibles, consultez le paramètre kind dans le Guide de référence.

Créer des éléments / pages

Cet exemple crée un webpage sous le niveau supérieur du site, inclut du code XHTML pour le corps de la page et définit le titre de l'en-tête sur "Nouveau titre de page Web" :

private void setContentBlob(BaseContentEntry<?> entry, String pageContent) {
  XmlBlob xml = new XmlBlob();
  xml.setBlob(pageContent);
  entry.setContent(new XhtmlTextConstruct(xml));
}

public WebPageEntry createWebPage(String title, String content)
    throws MalformedURLException, IOException, ServiceException {
  WebPageEntry entry = new WebPageEntry();
  entry.setTitle(new PlainTextConstruct(title));

  setContentBlob(entry, content); // Entry's HTML content

  return client.insert(new URL(buildContentFeedUrl()), entry);
}

WebPageEntry createdEntry = createWebPage("New Webpage Title", "<b>HTML content</b>");
System.out.println("Created! View at " + createdEntry.getHtmlLink().getHref());

Si la requête aboutit, createdEntry contient une copie de l'entrée créée sur le serveur.

Créer des éléments/pages sous des chemins d'URL personnalisés

Par défaut, l'exemple précédent serait créé sous l'URL http://sites.google.com/site/siteName/new-webpage-title et aurait un titre de page "Nouveau titre de page Web". Autrement dit, <atom:title> est normalisé en new-webpage-title pour l'URL. Pour personnaliser le chemin d'URL d'une page, vous pouvez définir l'élément <sites:pageName>.

Cet exemple crée une page filecabinet avec un titre "File Storage" (Stockage de fichiers), mais crée la page sous l'URL http://sites.google.com/site/siteName/files (au lieu de http://sites.google.com/site/siteName/file-storage) en spécifiant l'élément <sites:pageName>.

public FileCabinetPageEntry createFileCabinetPage(String title, String content, String customPageName)
    throws MalformedURLException, IOException, ServiceException {
  FileCabinetPageEntry entry = new FileCabinetPageEntry();
  entry.setTitle(new PlainTextConstruct(title));

  setContentBlob(entry, content); // Entry's HTML content

  entry.setPageName(new PageName(customPageName)); // Upload to a custom page path

  return client.insert(new URL(buildContentFeedUrl()), entry);
}

FileCabinetPageEntry createdEntry = createFileCabinetPage("File Storage", "<b>HTML content</b>", "files");
System.out.println("Created! View at " + createdEntry.getHtmlLink().getHref());

Le serveur utilise les règles de priorité suivantes pour nommer le chemin d'URL d'une page :

1. <sites:pageName>, si disponible. Doit être conforme à a-z, A-Z, 0-9, -, _.
2. <atom:title> : ne doit pas être nul si pageName n'est pas présent. La normalisation consiste à supprimer les espaces blancs et à les remplacer par "-", et à supprimer les caractères ne correspondant pas à a-z, A-Z, 0-9, -, _.

Créer des sous-pages

Pour créer des sous-pages (enfants) sous une page parente, vous devez définir le lien parent dans l'entrée. L'attribut href du lien vers le lien "self" du nœud parent.

public AnnouncementEntry postAnnouncement(String title, String content, AnnouncementsPageEntry parentPage)
    throws MalformedURLException, IOException, ServiceException {
  AnnouncementEntry entry = new AnnouncementEntry();
  entry.setTitle(new PlainTextConstruct(title));

  setContentBlob(entry, content); // Entry's HTML content

  // Set the entry's parent link to create the announcement under that page.
  entry.addLink(SitesLink.Rel.PARENT, Link.Type.ATOM, parentPage.getSelfLink().getHref());

  return client.insert(new URL(buildContentFeedUrl()), entry);
}

ContentFeed contentFeed = client.getFeed(new URL(buildContentFeedUrl() + "?kind=announcementspage"), ContentFeed.class);

AnnouncementEntry createdEntry = postAnnouncement("Party!!", "My place, this weekend", contentFeed.getEntries().get(0));
System.out.println("New post by " + createdEntry.getAuthors().get(0).getName());

L'exemple ci-dessus crée un announcement sous la première page d'annonces trouvée dans le flux de contenu de l'utilisateur. Le titre de l'annonce est défini sur "Fête !" et le contenu sur "Chez moi, ce week-end".

Modèles de page

Créer des modèles de page

La procédure de création d'un modèle de page est la même que celle pour créer des éléments/pages et créer des sous-pages.La différence réside dans l'ajout de category avec le terme et le libellé définis sur "http://schemas.google.com/g/2005#template" et "template", respectivement.

Cet exemple crée un modèle webpage.

// The template webpage entry.
WebPageEntry entry = new WebPageEntry();

// Set title and content.
entry.setTitle(new PlainTextConstruct("Page template title"));
XmlBlob xml = new XmlBlob();
xml.setBlob("Content for page template");
entry.setContent(new XhtmlTextConstruct(xml));

// Set the template category
Category TEMPLATE_CATEGORY = new Category(TemplateCategory.Scheme.LABELS,
    TemplateCategory.Term.TEMPLATE, TemplateCategory.Label.TEMPLATE);
entry.getCategories().add(TEMPLATE_CATEGORY);

// Insert the template webpage entry.
WebPageEntry createdEntry = client.insert(new URL("https://sites.google.com/feeds/content/site/siteName"), entry);

Créer des pages à partir d'un modèle

Comme pour la création de modèles de page, vous pouvez instancier une nouvelle page à partir d'un modèle en incluant un <link> avec rel='http://schemas.google.com/sites/2008#template' pointant vers le lien vers soi d'un modèle de page.

Cet exemple crée un modèle filecabinet, puis instancie une page filecabinet à partir de ce modèle.

URL feedUrl = new URL("https://sites.google.com/feeds/content/site/siteName");

// 1. Create file cabinet page template
FileCabinetPageEntry inputTemplateEntry = new FileCabinetPageEntry();
inputTemplateEntry.setTitle(new PlainTextConstruct("File cabinet page template title"));
XmlBlob xml = new XmlBlob();
xml.setBlob("Content for page template");
inputTemplateEntry.setContent(new XhtmlTextConstruct(xml));

// Set the template category
Category TEMPLATE_CATEGORY = new Category(TemplateCategory.Scheme.LABELS,
    TemplateCategory.Term.TEMPLATE, TemplateCategory.Label.TEMPLATE);
inputTemplateEntry.getCategories().add(TEMPLATE_CATEGORY);

// 2. Create file cabinet page template instance
FileCabinetPageEntry templateEntry = client.insert(feedUrl, inputTemplateEntry);

// Specify link to the page template
FileCabinetPageEntry templateInstanceEntry = new FileCabinetPageEntry();
templateInstanceEntry.setTitle(new PlainTextConstruct("File cabinet template instance"));
templateInstanceEntry.addLink(new Link(SitesLink.Rel.TEMPLATE, Link.Type.ATOM, templateEntry.getSelfLink().getHref()));

FileCabinetPageEntry createdFileCabinetFromTemplate =  client.insert(feedUrl, templateInstanceEntry);

Remarque : Même si un modèle définit un <category>, vous devez quand même en inclure un dans votre entrée. Notez également que si vous incluez un élément <content>, le serveur le refusera.

Importer des fichiers

Comme dans Google Sites, l'API permet d'importer des pièces jointes sur une page de classeur ou une page parente.

Pour importer une pièce jointe dans un contenu parent, envoyez une requête HTTP POST à l'URL du flux de contenu :

https://sites.google.com/feeds/content/site/siteName

Tous les types de pièces jointes doivent être importés sur une page parente. Vous devez donc définir un lien parent sur l'objet AttachmentEntry ou WebAttachmentEntry que vous essayez d'importer. Pour en savoir plus, consultez Créer des sous-pages.

Transfert de pièces jointes

Cet exemple importe un fichier PDF dans le premier FileCabinetPageEntry trouvé dans le flux de contenu de l'utilisateur. La pièce jointe est créée avec le titre "Premiers pas" et la description (facultative) "Dossier RH".

MimetypesFileTypeMap mediaTypes = new MimetypesFileTypeMap();
mediaTypes.addMimeTypes("application/msword doc");
mediaTypes.addMimeTypes("application/vnd.ms-excel xls");
mediaTypes.addMimeTypes("application/pdf pdf");
mediaTypes.addMimeTypes("text/richtext rtx");
// ... See a more complete list of mime types in the SitesHelper.java

public AttachmentEntry uploadAttachment(File file, BasePageEntry<?> parentPage,
    String title, String description) throws IOException, ServiceException {
  AttachmentEntry newAttachment = new AttachmentEntry();
  newAttachment.setMediaSource(new MediaFileSource(file, mediaTypes.getContentType(file)));
  newAttachment.setTitle(new PlainTextConstruct(title));
  newAttachment.setSummary(new PlainTextConstruct(description));
  newAttachment.addLink(SitesLink.Rel.PARENT, Link.Type.ATOM, parentPage.getSelfLink().getHref());

  return client.insert(new URL(buildContentFeedUrl()), newAttachment);
}

ContentFeed contentFeed = client.getFeed(new URL(buildContentFeedUrl() + "?kind=filecabinet"), ContentFeed.class);
FileCabinetPageEntry parentPage = contentFeed.getEntries(FileCabinetPageEntry.class).get(0);

AttachmentEntry attachment = uploadAttachment(
    new File("/path/to/your/file.pdf"), parentPage, "Getting Started", "HR packet");
System.out.println("Uploaded!");

Si l'importation réussit, attachment contient une copie de l'entrée de pièce jointe créée.

Importer une pièce jointe dans un dossier

Pour importer une pièce jointe dans un dossier existant d'un FileCabinetPageEntry, incluez une catégorie dont l'attribut "term" est défini sur le nom du dossier. Par exemple, ajoutez cette ligne dans uploadAttachment() :

newAttachment.getCategories().add(new Category("http://schemas.google.com/sites/2008#folder", "FolderName"));

Pièces jointes Web

Les pièces jointes Web sont des types spéciaux de pièces jointes. Il s'agit essentiellement de liens vers d'autres fichiers sur le Web que vous pouvez ajouter à vos fiches de classeur. Cette fonctionnalité est analogue à la méthode d'importation "Ajouter un fichier par URL" dans l'interface utilisateur de Google Sites.

Remarque : Les pièces jointes Web ne peuvent être créées que dans un fichier cabinet. Vous ne pouvez pas les importer sur d'autres types de pages.

Cet exemple crée un WebAttachmentEntry sous le premier FileCabinetPageEntry trouvé dans le flux de contenu de l'utilisateur. Son titre et sa description (facultative) sont définis sur "GoogleLogo" et "nice colors", respectivement.

public WebAttachmentEntry uploadWebAttachment(String contentUrl, FileCabinetPageEntry filecabinet,
    String title, String description) throws MalformedURLException, IOException, ServiceException {
  MediaContent content = new MediaContent();
  content.setUri(contentUrl);

  WebAttachmentEntry webAttachment = new WebAttachmentEntry();
  webAttachment.setTitle(new PlainTextConstruct(title));
  webAttachment.setSummary(new PlainTextConstruct(description));
  webAttachment.setContent(content);
  webAttachment.addLink(SitesLink.Rel.PARENT, Link.Type.ATOM,
      filecabinet.getSelfLink().getHref());

  return client.insert(new URL(buildContentFeedUrl()), webAttachment);
}

ContentFeed contentFeed = client.getFeed(new URL(buildContentFeedUrl() + "?kind=filecabinet"), ContentFeed.class);
FileCabinetPageEntry parentPage = contentFeed.getEntries(FileCabinetPageEntry.class).get(0);

WebAttachmentEntry webAttachment =
    uploadWebAttachment("http://www.google.com/images/logo.gif", parentPage, "Google's Logo", "nice colors");
System.out.println("Web attachment created!");

POST crée un lien dans le fichier de l'utilisateur qui pointe vers l'image à l'adresse "http://www.google.com/images/logo.gif".

Haut de page

Mettre à jour le contenu

Mettre à jour les métadonnées et/ou le contenu HTML d'une page

Les métadonnées (titre, pageName, etc.) et le contenu de la page de tout type BaseContentEntry peuvent être modifiés à l'aide de la méthode update() de l'entrée. Cela enverra une requête HTTP PUT au lien edit de l'entrée.

Voici un exemple de mise à jour d'un ListPageEntry avec les modifications suivantes :

• Le titre est modifié et devient "Titre modifié".
• Le contenu HTML de la page est mis à jour et devient "<p>Updated HTML Content</p>".
• L'en-tête de la première colonne de la liste est remplacé par "Propriétaire".

ContentFeed contentFeed = client.getFeed(
    new URL(buildContentFeedUrl() + "?kind=listpage"), ContentFeed.class);
ListPageEntry listPage = contentFeed.getEntries(ListPageEntry.class).get(0); // Update first list page found

// Update title
listPage.setTitle(new PlainTextConstruct("Updated Title"));

// Update HTML content
XmlBlob xml = new XmlBlob();
xml.setBlob("<p>Updated HTML Content</p>");
listPage.setContent(new XhtmlTextConstruct(xml));

// Change first column's heading
listPage.getData().getColumns().get(0).setName("Owner");

// listPage.setPageName(new PageName("new-page-path"));  // You can also change the page's URL path

ListPageEntry updatedEntry = listPage.update();

System.out.println("ListPage updated!");

Modifier le contenu d'un fichier joint

Pour AttachmentEntry, vous pouvez également mettre à jour le contenu en définissant le MediaSource de l'entrée, puis en utilisant la méthode updateMedia(boolean) de l'entrée.

Cet exemple met à jour le contenu d'une pièce jointe existante :

public AttachmentEntry updateFile(AttachmentEntry entry, File newFile)
    throws IOException, ServiceException {
  // See Uploading Attachments for the definition of mediaTypes.
  entry.setMediaSource(new MediaFileSource(newFile, mediaTypes.getContentType(newFile)));
  return entry.updateMedia(false);
}

L'exemple envoie une requête HTTP PUT au lien edit-media de l'entrée. Le AttachmentEntry renvoyé contient le contenu mis à jour.

Mettre à jour les métadonnées et le contenu des pièces jointes

Vous pouvez mettre à jour les métadonnées et le contenu d'une pièce jointe dans le même appel à l'aide de la méthode updateMedia(). Vous pouvez mettre à jour le contenu du fichier, les métadonnées ou les deux.

Cet exemple modifie le titre de la pièce jointe en "Nouveau titre", met à jour sa description et remplace le contenu du fichier par un nouveau fichier .zip. Étant donné que la requête contient un nouveau contenu de fichier, le updateMedia() de AttachmentEntry est utilisé.

public AttachmentEntry updateAttachment(AttachmentEntry entry, File newFile, String newTitle, String newDescription)
    throws IOException, ServiceException  {
  // See Uploading Attachments for the definition of mediaTypes.
  entry.setMediaSource(new MediaFileSource(newFile, mediaTypes.getContentType(newFile)));
  entry.setTitle(new PlainTextConstruct(newTitle));
  entry.setSummary(new PlainTextConstruct(newDescription));

  return entry.updateMedia(true);
}

ContentFeed contentFeed = client.getFeed(
    new URL(buildContentFeedUrl() + "?kind=attachment&max-results=1"), ContentFeed.class);
AttachmentEntry attachment = contentFeed.getEntries(AttachmentEntry.class).get(0); // Update first attachment found

AttachmentEntry updatedAttachment = updateAttachment(attachment, new File("/path/to/file.zip"), "New Title", "better stuff");

Haut de page

Supprimer du contenu

Pour supprimer une page ou un élément d'un site Google, récupérez d'abord l'entrée de contenu, puis appelez la méthode delete() de l'entrée.

entry.delete();

Vous pouvez également utiliser la méthode delete() de la classe de service en lui transmettant le lien edit et la valeur ETag de l'entrée :

client.delete(entry.getEditLink().getHref(), "*"); // Note: using "*" may overwrite another client's changes.

Si l'entrée a été supprimée, le serveur répond par un HTTP 200 OK.

Haut de page

Télécharger des pièces jointes

Pour télécharger un AttachmentEntry, envoyez une requête HTTP GET au lien content src de l'entrée.

Cet exemple télécharge le premier AttachmentEntry trouvé dans le flux de contenu de l'utilisateur vers le répertoire "/path/to/save/file/" :

private void downloadFile(String downloadUrl, String fullFilePath) throws IOException, ServiceException {
  System.out.println("Downloading file from: " + downloadUrl);

  MediaContent mc = new MediaContent();
  mc.setUri(downloadUrl);
  MediaSource ms = service.getMedia(mc);

  InputStream inStream = null;
  FileOutputStream outStream = null;

  try {
    inStream = ms.getInputStream();
    outStream = new FileOutputStream(fullFilePath);

    int c;
    while ((c = inStream.read()) != -1) {
      outStream.write(c);
    }
  } finally {
    if (inStream != null) {
      inStream.close();
    }
    if (outStream != null) {
      outStream.flush();
      outStream.close();
    }
  }
}

public void downloadAttachment(AttachmentEntry entry, String directory) throws IOException, ServiceException {
  String url = ((OutOfLineContent) entry.getContent()).getUri();
  downloadFile(url, directory + entry.getTitle().getPlainText()); // Use entry's title for the save filename
}

ContentFeed contentFeed = client.getFeed(
    new URL(buildContentFeedUrl() + "?kind=attachment&max-results=1"), ContentFeed.class);

downloadAttachment(contentFeed.getEntries(AttachmentEntry.class).get(0), "/path/to/save/file/");
System.out.println("Downloaded.");

Haut de page

Flux de la LCA

Présentation des autorisations de partage (LCA)

Chaque entrée de LCA dans le flux de LCA représente un rôle d'accès d'une entité spécifique (utilisateur, groupe d'utilisateurs, domaine ou accès par défaut, qui correspond à un site public). Les entrées ne s'affichent que pour les entités ayant un accès explicite. Une entrée s'affiche pour chaque adresse e-mail dans le panneau "Personnes ayant accès" de l'écran de partage de l'interface utilisateur Google Sites. Par conséquent, les administrateurs de domaine ne s'afficheront pas, même s'ils ont un accès implicite à un site.

Rôles

L'élément "role" représente un niveau d'accès qu'une entité peut avoir. L'élément gAcl:role peut avoir quatre valeurs :

• Lecteur : un lecteur (équivalent à un accès en lecture seule).
• writer : collaborateur (équivaut à un accès en lecture/écriture).
• owner : il s'agit généralement de l'administrateur du site (équivalent à un accès en lecture/écriture).

Niveaux d'accès

L'élément "scope" représente l'entité qui dispose de ce niveau d'accès. L'élément gAcl:scope peut avoir quatre types :

• user : valeur d'adresse e-mail, par exemple "user@gmail.com".
• group : adresse e-mail d'un groupe Google Groupes (par exemple, "group@domain.com").
• domain : nom de domaine G Suite, par exemple "domain.com".
• default : il n'existe qu'un seul champ d'application de type "default", qui n'a aucune valeur (par exemple, <gAcl:scope type="default">). Ce champ d'application spécifique contrôle l'accès dont dispose tout utilisateur par défaut sur un site public.

Remarque : Les domaines ne peuvent pas avoir une valeur gAcl:role définie sur "accès propriétaire". Ils ne peuvent être que lecteurs ou rédacteurs.

Récupérer le flux de LCA

Les classes AclFeed et AclEntry peuvent être utilisées pour contrôler les autorisations de partage d'un site. Elles peuvent être récupérées à l'aide de la méthode getFeed() de la classe de service.

L'exemple suivant récupère le flux de LCA pour un site donné et affiche les autorisations de chaque AclEntry :

public String getAclFeedUrl(String siteName) {
  String domain = "site";  // OR if the Site is hosted on G Suite, your domain (e.g. example.com)
  return "https://sites.google.com/feeds/acl/site/" + domain + "/" + siteName + "/";
}

public void getAclFeed(String siteName) throws IOException, ServiceException {
  AclFeed aclFeed = client.getFeed(new URL(getAclFeedUrl(siteName)), AclFeed.class);
  for (AclEntry entry : aclFeed.getEntries()) {
    System.out.println(entry.getScope().getValue() + " (" + entry.getScope().getType() + ") : " +
                       entry.getRole().getValue());
  }
}

getAclFeed('my-site-name');

Si vous travaillez avec des entrées dans SiteFeed, chaque SiteEntry contient un lien vers son flux de LCA. Par exemple, cet extrait récupère le flux ACL d'un SiteEntry :

String aclLink = siteEntry.getLink(SitesAclFeedLink.Rel.ACCESS_CONTROL_LIST, Link.Type.ATOM).getHref();
AclFeed aclFeed = client.getFeed(new URL(aclLink), AclFeed.class);

Partager un site

Remarque : Certaines LCA de partage ne sont possibles que si le domaine est configuré pour autoriser de telles autorisations (par exemple, si le partage en dehors du domaine pour les domaines G Suite est activé, etc.).

Pour partager un site Google Sites à l'aide de l'API, votre client doit créer un AclEntry et l'envoyer au serveur.POST

Voici un exemple qui ajoute "user@example.com" en tant que reader sur le site :

AclRole role = new AclRole("reader");
AclScope scope = new AclScope(AclScope.Type.USER, "user@example.com");
AclEntry aclEntry = addAclRole(role, scope, entry);

public AclEntry addAclRole(AclRole role, AclScope scope, SiteEntry siteEntry)
    throws IOException, MalformedURLException, ServiceException  {
  AclEntry aclEntry = new AclEntry();
  aclEntry.setRole(role);
  aclEntry.setScope(scope);

  Link aclLink = siteEntry.getLink(SitesAclFeedLink.Rel.ACCESS_CONTROL_LIST, Link.Type.ATOM);
  return client.insert(new URL(aclLink.getHref()), aclEntry);
}

Consultez la section Présentation du flux de LCA pour connaître les valeurs possibles de AclScope et AclRoles.

Partage au niveau du groupe et du domaine

Comme pour le partage d'un site avec un seul utilisateur, vous pouvez partager un site avec un groupe Google ou un domaine G Suite.

Partage avec une adresse e-mail de groupe :

AclScope scope = new AclScope(AclScope.Type.GROUP, "group_name@example.com");

Partager avec l'ensemble d'un domaine :

AclScope scope = new AclScope(AclScope.Type.DOMAIN, "example.com");

Le partage au niveau du domaine n'est disponible que pour les domaines G Suite et uniquement pour le domaine sur lequel le site est hébergé. Par exemple, http://sites.google.com/a/domain1.com/siteA ne peut partager l'intégralité du site qu'avec domain1.com, et non avec domain2.com. Les sites qui ne sont pas hébergés sur un domaine G Suite (par exemple, http://sites.google.com/site/siteB) ne peuvent pas inviter de domaines.

Modifier les autorisations de partage

Pour modifier une autorisation de partage existante sur un site, commencez par récupérer le AclEntry en question, modifiez l'autorisation comme vous le souhaitez, puis appelez la méthode update() du AclEntry pour modifier la LCA sur le serveur.

Cet exemple modifie notre exemple aclEntry précédent de la section Partager un site en remplaçant "user@example.com" par un writer (collaborateur) :

aclEntry.setRole(new AclRole("writer"));
AclEntry updatedAclEntry = aclEntry.update();

// Could also use the client's update method
// client.update(new URL(aclEntry.getEditLink().getHref()), aclEntry);

Pour en savoir plus sur les ETag, consultez le guide de référence des API Google Data.

Supprimer les autorisations de partage

Pour supprimer une autorisation de partage, récupérez d'abord le AclEntry, puis appelez sa méthode delete() :

aclEntry.delete();

// Could also use the client's delete method
// client.delete(new URL(aclEntry.getEditLink().getHref()), aclEntry);

Pour en savoir plus sur les ETag, consultez le guide de référence des API Google Data.

Haut de page

Thèmes spéciaux

Récupérer à nouveau un flux ou une entrée

Si vous souhaitez récupérer un flux ou une entrée que vous avez déjà récupérés, vous pouvez améliorer l'efficacité en indiquant au serveur d'envoyer la liste ou l'entrée uniquement si elle a changé depuis la dernière fois que vous l'avez récupérée.

Pour effectuer ce type de récupération conditionnelle, les méthodes getFeed() et getEntry() fournissent un argument supplémentaire qui accepte une valeur ETag ou un objet DateTime pour l'en-tête If-Modified-Since. Vous pouvez accéder à l'etag d'une entrée à partir de entry.getEtag().

Cet exemple effectue une récupération conditionnelle pour une entrée de page Web de contenu :

String feedUrl = "https://sites.google.com/feeds/content/site/siteName/123456789";
WebPageEntry entry = client.getEntry(new URL(feedUrl), WebPageEntry.class, "\"GVQHSARDQyp7ImBq\"");

Lorsque le serveur reçoit cette requête, il vérifie si l'élément que vous avez demandé possède la même ETag que celle que vous avez spécifiée. Si les ETag correspondent, l'élément n'a pas été modifié et le serveur renvoie une exception HTTP 304 NotModifiedException.

Si les ETags ne correspondent pas, cela signifie que l'élément a été modifié depuis votre dernière requête. Le serveur renvoie alors l'élément.

Pour en savoir plus sur les ETag, consultez le guide de référence des API Google Data.

Haut de page