Obsolète: l'API Sites est obsolète et peut cesser de fonctionner à tout moment. L'API Sites ne peut accéder qu'à la version classique de Sites. L'API Sites ne permet pas d'accéder à la version recompilée de Sites lancée le 22 novembre 2016.

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

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 depuis le 20 avril 2012 et ne sont plus disponibles. Nous vous encourageons à passer à OAuth 2.0 dès que possible.

L'API Google Sites Data permet aux applications clientes d'accéder, de publier et de modifier le contenu d'un site Google. 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 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 pour configurer la bibliothèque cliente, consultez Premiers pas avec la bibliothèque cliente Java Google Data. Pour en savoir plus sur le protocole sous-jacent utilisé par la bibliothèque cliente Java pour interagir avec l'API de la version classique de Sites, consultez le guide du protocole.

Audience

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

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

Si vous avez besoin d'aide pour configurer et installer la bibliothèque cliente, consultez la page Premiers pas avec la bibliothèque cliente Google Data pour Java. Si vous utilisez Eclipse, cet article explique également comment configurer votre projet à l'aide du plug-in Eclipse des API Google Data. Voici ce dont vous avez besoin pour commencer:

Installez Java 1.5 ou version ultérieure.
Télécharger la bibliothèque cliente (la dernière version de gdata-src.java.zip)
Télécharger la liste des dépendances
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:

java/lib/gdata-sites-2.0.jar : la version 2.0 est destinée à la version 1.4 de l'API Google Sites classique.
java/lib/gdata-core-1.0.jar
java/lib/gdata-client-1.0.jar
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 complet et fonctionnel se trouve dans le sous-répertoire /java/sample/sites du fichier gdata-samples.java.zip téléchargé. La source est également disponible à l'adresse /trunk/java/sample/sites/ dans le dépôt SVN accessible depuis l'onglet "Source". Le SitesDemo.java permet à l'utilisateur d'effectuer un certain nombre d'opérations qui montrent comment utiliser l'API de la version classique de Sites.

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 Using Eclipse with Google Data APIs (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.*;

Ensuite, vous devez également configurer un objet SitesService, qui représente une connexion client à l'API Google Sites classique:

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

L'argument applicationName doit respecter le format 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 classique

La bibliothèque cliente Java peut être utilisée pour travailler avec des flux publics ou privés. L'API Sites Data permet d'accéder à des flux privés et publics, en fonction des autorisations Sites et de l'opération que vous essayez d'effectuer. Par exemple, vous pouvez être en mesure de lire le flux de contenu d'un site public, mais pas de le modifier (ce qui nécessite un client authentifié). Vous pouvez le faire 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 via les API Google Data.

Conseil : L'API est compatible avec SSL (HTTPS). Si vous utilisez AuthSub/OAuth, veillez à spécifier un champ d'application de https://sites.google.com/feeds/ pour demander des flux via SSL. Notez également que pour les domaines G Suite, le paramètre "Exiger la conformité à la norme SSL" du panneau de configuration administratif 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.

Consulter les instructions pour intégrer AuthSub à votre application Web

Demander un jeton à usage unique

Lorsque l'utilisateur accède à votre application pour la première fois, il doit s'authentifier. En règle générale, les développeurs impriment du texte et un lien redirigeant l'utilisateur vers la page d'approbation AuthSub pour l'authentifier et demander l'accès à ses documents. La bibliothèque cliente Java Google Data fournit une fonction permettant de générer cette URL. Le code ci-dessous configure un lien vers la page AuthSubRequest.

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

Si vous souhaitez authentifier les utilisateurs sur votre domaine hébergé par G Suite:

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

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

l'URL suivante : URL vers laquelle Google redirige l'utilisateur après qu'il s'est connecté à son compte et accordé l'accès ; http://www.example.com/welcome.jsp dans l'exemple ci-dessus
le champ d'application (https://sites.google.com/feeds/ dans l'exemple ci-dessus)
Valeur booléenne indiquant si le jeton sera utilisé ou non en mode enregistré (false dans l'exemple ci-dessus).
Une deuxième valeur booléenne pour indiquer si le jeton sera ultérieurement échangé contre un jeton de session ou non (true dans l'exemple ci-dessus).

OAuth pour les applications Web ou installées/mobiles

OAuth peut être utilisé à la place d'AuthSub et est destiné aux applications Web. OAuth est semblable à l'utilisation du mode sécurisé et enregistré d'AuthSub, dans la mesure où toutes les requêtes de données doivent être signées numériquement et que vous devez enregistrer votre domaine.

Afficher les instructions pour intégrer OAuth dans votre application installée

Récupérer un jeton de requête

Consultez la page Utiliser OAuth avec les bibliothèques clientes de l'API Google Data.

Autoriser un jeton de requête

Consultez Utiliser OAuth avec les bibliothèques clientes de l'API Google Data.

Passer à un jeton d'accès

Consultez Utiliser OAuth avec les bibliothèques clientes de l'API Google Data.

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 de comptes Google. Lors de la première exécution, votre application invite l'utilisateur à saisir son nom d'utilisateur et son mot de passe. Lors des requêtes suivantes, un jeton d'authentification est référencé.

Consulter les instructions d'intégration de ClientLogin à votre application installée

Pour utiliser ClientLogin, appelez la méthode setUserCredentials() de l'objet SitesService, qui est héritée de GoogleService. Spécifiez l'adresse e-mail et le mot de passe de l'utilisateur au nom duquel votre client envoie des requêtes. Exemple :

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

Conseil : Une fois que votre application a authentifié l'utilisateur pour la première fois, stockez le jeton d'authentification dans votre base de données pour pouvoir le rappeler plus tard. Il n'est pas nécessaire de demander à l'utilisateur son mot de passe à chaque exécution de votre application. Pour en savoir plus, consultez la section Rappeler un jeton d'authentification.

Pour en savoir plus sur l'utilisation de ClientLogin dans vos applications Java, consultez Utiliser ClientLogin avec les bibliothèques clientes de l'API Google Data.

Haut de page

Flux d'actualisation

Le flux de sites permet de lister les sites Google Sites dont un utilisateur est propriétaire ou pour lesquels il dispose d'autorisations de consultation. Vous pouvez également l'utiliser 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.

Sites de référencement

Pour interroger le flux de site, envoyez un GET HTTP à 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 ci-dessus imprime le titre, le nom et le thème du site. 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.

Vous pouvez provisionner de nouveaux sites en créant un SiteEntry et en appelant la méthode insert() du client sur le flux de sites.

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

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 crée un site sous le domaine G Suite example.com. Ainsi, l'URL du site se présentera comme suit : https://sites.google.com/a/example.com/mon-titre-site.

Si le site est créé, le serveur répond avec un objet SiteEntry, renseigné par 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.

La copie d'un site est semblable à la création d'un site. La différence est que vous devez définir un lien sur votre nouvelle SiteEntry qui inclut le lien vers le site à dupliquer. Voici un exemple de dupliquer le 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 sites appartenant à l'utilisateur authentifié peuvent être copiés.
Vous pouvez également copier un modèle de site. Un site est un modèle si l'option "Publier ce site comme modèle" est cochée sur la page des paramètres de Google Sites.
Vous pouvez copier un site d'un autre domaine tant que vous n'êtes pas indiqué comme propriétaire du site source.

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

Pour renommer un site, modifier son thème, sa balise de catégorie ou son résumé, vous devez d'abord extraire 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 renomme le site:

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 de mapper leurs propres domaines sur 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'emplacement où votre site est hébergé, vous pouvez modifier manuellement les mappages d'adresses Web d'un site. Pour en savoir plus, consultez notre 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 de 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 mises en correspondance existantes s'affichent sous forme de link avec rel='webAddressMapping'. Par exemple, dans l'exemple ci-dessus, trois webAddressMapping 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, les webAddressMappings ne sont pas renvoyés dans les entrées de site (GET) et ne sont pas pris en compte lors de la mise à jour/suppression des mappages (PUT) d'une entrée.

Pour ajouter, mettre à jour ou supprimer un mappage, il vous suffit de spécifier, modifier ou supprimer ce lien lors de la création de sites ou de la mise à jour des métadonnées d'un site. Le paramètre with-mappings=true doit être inclus dans l'URI du flux de site. Remarque : Pour modifier les mises en correspondance d'adresses, vous devez être administrateur du site ou administrateur de domaine dans le cas d'un site hébergé par 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 l'élément http://www.mysitemapping2.com en laissant le lien en dehors de 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 mises en correspondance d'adresses Web au moment de créer ou de copier 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és. 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 la section 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 un GET HTTP 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évision 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 la section 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. Pour y accéder, envoyez un GET HTTP à l'URL du flux de contenu :

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

Paramètre de flux	Description
`site`	"`site`" ou le domaine de votre domaine hébergé G Suite (par exemple, `example.com`).
`siteName`	Nom de l'espace Web de votre site, indiqué dans l'URL du site (par exemple, `mySite`).

Exemple d'extraction 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 sur le site de l'utilisateur. ContentFeed contiendra 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 une ContentFeed. Chaque type d'entrée contient des propriétés différentes, mais toutes ne sont pas imprimé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 la section S'authentifier auprès du service Sites.

Exemples de requêtes pour les flux de contenu

Vous pouvez rechercher dans le flux de contenu à l'aide de certains des paramètres de requête standards de l'API Google Data et de ceux spécifiques à l'API Sites classique. 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 ne récupérer qu'un type d'entrée particulier, utilisez le paramètre kind. Cet exemple ne renvoie que des 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 des 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 son chemin d'accès

Si vous connaissez le chemin d'accès relatif d'une page du site Google, vous pouvez utiliser le paramètre path pour récupérer cette page en particulier. Cet exemple renverrait la page située à l'emplacement 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 en savoir plus sur les paramètres supplémentaires, consultez le guide de référence.

Haut de page

Création de 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";

Vous pouvez créer du contenu (pages Web, pages de liste, pages de fichiers, pages d'annonces, etc.) en envoyant un POST HTTP au flux de contenu :

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

Pour obtenir la liste des types de nœuds d'assistance, consultez le paramètre kind dans le guide de référence.

Créer des éléments/pages

Cet exemple crée un nouvel webpage sous le niveau de premier niveau du site, inclut du code XHTML pour le corps de la page et définit le titre d'en-tête sur "Nouveau titre de la 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 est créé sous l'URL http://sites.google.com/site/siteName/new-webpage-title et possède l'en-tête "New Webpage Title" (Nouveau titre de la page Web). Autrement dit, pour l'URL, <atom:title> est normalisé en new-webpage-title. Pour personnaliser le chemin d'accès à l'URL d'une page, vous pouvez définir l'élément <sites:pageName>.

Cet exemple crée une page filecabinet avec l'en-tête "File Storage" (Stockage de fichiers), mais la crée 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'accès à l'URL d'une page :

<sites:pageName>, si présent. Doit être conforme à a-z, A-Z, 0-9, -, _.
<atom:title>, ne doit pas être nul si "pageName" n'est pas présent. La normalisation consiste à couper et à réduire les espaces en tabulation à "-", et à supprimer les caractères qui ne correspondent pas à a-z, A-Z, 0-9, -, _.

Créer des sous-pages

Pour créer des sous-pages (enfants) sous une page parent, vous devez définir le lien parent dans l'entrée. L'attribut href du lien vers le lien auto 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 "Fête !!" et le contenu est "Chez moi, ce week-end".

Modèles de page

Créer des modèles de page

Le processus de création d'un modèle de page est le même que celui de création d'éléments/de pages et de création de 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 créer des modèles de page, vous pouvez instancier une page à partir d'un modèle en incluant un <link> avec rel='http://schemas.google.com/sites/2008#template' pointant vers l'auto-lien 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 toujours 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 à un 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. Le fichier joint est créé avec le titre "Premiers pas" et une description (facultative) "Paquet 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 créée en pièce jointe.

Importer une pièce jointe dans un dossier

Pour importer une pièce jointe dans un dossier existant dans un FileCabinetPageEntry, ajoutez une catégorie avec l'attribut "term" 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 de pièces jointes spéciaux. Il s'agit essentiellement de liens vers d'autres fichiers sur le Web que vous pouvez ajouter aux fiches de votre fichier cabinet. Cette fonctionnalité est semblable à 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 classeur. Vous ne pouvez pas les importer vers 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 "Belles couleurs".

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 dossier de l'utilisateur pointant vers l'image sur "http://www.google.com/images/logo.gif".

Haut de page

Modifier le contenu

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

Les métadonnées (title, 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. Une requête PUT HTTP est alors envoyée au lien edit de l'entrée.

Vous trouverez ci-dessous un exemple de mise à jour d'un ListPageEntry avec les modifications suivantes :

Le titre est remplacé par "Titre mis à jour".
Le contenu HTML de la page est mis à jour pour afficher "<p>Contenu HTML mis à jour</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'une pièce jointe

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 PUT HTTP à l'association edit-media de l'entrée. Le AttachmentEntry renvoyé contient le contenu mis à jour.

Mettre à jour les métadonnées et le contenu d'une pièce jointe

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 uniquement le contenu du fichier, les métadonnées ou les deux.

Dans cet exemple, le titre de la pièce jointe est remplacé par "Nouveau titre", la description est mise à jour et le contenu du fichier est remplacé par un nouveau fichier .zip. Étant donné que la requête contient du contenu de nouveau 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 l'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 bien été supprimée, le serveur renvoie un code 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 src du contenu de l'entrée.

Cet exemple télécharge le premier AttachmentEntry trouvé dans le flux de contenu de l'utilisateur dans 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 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é particulière, qu'il s'agisse d'un utilisateur, d'un groupe d'utilisateurs, d'un domaine ou de l'accès par défaut (qui est un site public). Les entrées ne s'affichent que pour les entités disposant d'un accès explicite. Une entrée s'affiche pour chaque adresse e-mail dans le panneau "Utilisateurs disposant d'un accès" de l'écran de partage de l'interface utilisateur de Google Sites. Par conséquent, les administrateurs de domaine ne s'affichent pas, même s'ils disposent d'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:

reader : lecteur (équivalent à l'accès en lecture seule).
Rédacteur : collaborateur (équivalent à l'accès en lecture/écriture).
owner : généralement l'administrateur du site (équivalent à un accès en lecture/écriture).

Niveaux d'accès

L'élément du champ d'application représente l'entité disposant de ce niveau d'accès. Il existe quatre types d'éléments gAcl:scope possibles :

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

Remarque: Les domaines ne peuvent pas avoir une valeur gAcl:role définie sur l'accès "propriétaire". Ils ne peuvent être que des lecteurs ou des 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 et peuvent être extraites à l'aide de la méthode getFeed() de la classe de service.

L'exemple suivant extrait le flux LCA d'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 du flux SiteFeed, chaque SiteEntry contient un lien vers son flux de LCA. Par exemple, cet extrait extrait le flux LCA 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 est activé pour les domaines G Suite, etc.).

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

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

Pour connaître les valeurs possibles de AclScope et de AclRoles, consultez la section Présentation du flux d'ACL.

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.

Partager 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 possible 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 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.

Modification des autorisations de partage

Pour obtenir 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() de AclEntry pour modifier la LCA sur le serveur.

Cet exemple modifie notre exemple aclEntry précédent de la section Partager un site en définissant "user@example.com" comme 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 ETags, 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 l'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 ETags, consultez le guide de référence des API Google Data.

Haut de page

Sujets spéciaux

Récupérer 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 demandant au serveur d'envoyer la liste ou l'entrée uniquement si elle a été modifiée depuis votre dernière récupération.

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 demandé possède le même ETag que l'ETag que vous avez spécifié. Si les ETag correspondent, l'élément n'a pas changé 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 la dernière fois que vous l'avez demandé, et le serveur renvoie l'élément.

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

Haut de page

Guide du langage Java

Audience

Premiers pas

Installer la bibliothèque

Exécuter l'exemple d'application

Démarrer votre propre projet

S'authentifier dans l'API Sites classique

AuthSub pour les applications Web

Demander un jeton à usage unique

Passer à un jeton de session

Récupérer des informations sur un jeton de session

Révoquer un jeton de session

OAuth pour les applications Web ou installées/mobiles

Récupérer un jeton de requête

Autoriser un jeton de requête

Passer à un jeton d'accès

ClientLogin pour les applications installées/mobiles

Flux d'actualisation

Sites de référencement

Créer des sites

Copier un site

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

Mappages d'adresses Web

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

Modifier les mappages d'adresses Web

Flux d'activités

Flux de révisions

Flux de contenu

Récupérer le flux de contenu

Exemples de requêtes pour les flux de contenu

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

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

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

Création de contenu

Créer des éléments/pages

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

Créer des sous-pages

Modèles de page

Créer des modèles de page

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

Importer des fichiers

Transfert de pièces jointes

Importer une pièce jointe dans un dossier

Pièces jointes Web

Modifier le contenu

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

Modifier le contenu d'une pièce jointe

Mettre à jour les métadonnées et le contenu d'une pièce jointe

Supprimer du contenu

Télécharger des pièces jointes

Flux LCA

Présentation des autorisations de partage (LCA)

Rôles

Niveaux d'accès

Récupérer le flux de LCA

Partager un site

Partage au niveau du groupe et du domaine

Modification des autorisations de partage

Supprimer les autorisations de partage

Sujets spéciaux

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