Une version recompilée de Sites a été lancée le 22 novembre 2016. L'API Sites ne peut pas accéder aux sites créés avec cette version ni les modifier, mais peut toujours accéder à la version classique de Sites.

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 à 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 la 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 présenter 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 la page 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 pour les données.

Premiers pas

Google Sites utilise les comptes Google ou G Suite pour l'authentification. Si vous avez déjà un compte, vous n'avez rien d'autre à 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 Java Google Data. 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:

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

Après avoir installé le fichier .jars, vous devez inclure les éléments suivants dans votre projet:

java/lib/gdata-sites-2.0.jar : ici 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 / éléments de liste)

Veillez également à inclure les dépendances JAR (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 fichier gdata-samples.java.zip téléchargé. La source est également disponible sous /trunk/java/sample/sites/ dans le dépôt SVN accessible à partir de l'onglet Source. SitesDemo.java permet à l'utilisateur d'effectuer un certain nombre d'opérations montrant comment utiliser l'API de la version classique de Sites.

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

Démarrer votre propre projet

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

En fonction des 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 de la version classique de 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 suppose que vous avez créé un SitesService dans la variable client.

Authentification dans l'API Google 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 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 ne pas le mettre à jour (ce qui nécessiterait un client authentifié). Pour ce faire, utilisez l'authentification par nom d'utilisateur/mot de passe ClientLogin, AuthSub ou OAuth.

Pour plus d'informations sur AuthSub, OAuth et ClientLogin, consultez la page Présentation de l'authentification via les API Google Data.

Conseil: L'API est compatible avec le protocole SSL (HTTPS). Si vous utilisez AuthSub/OAuth, assurez-vous de spécifier le 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 connexion SSL" du panneau de configuration administratif est respecté par l'API. Vous pouvez forcer toutes les requêtes API à passer en 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 ni au mot de passe de l'utilisateur Google Sites. Seul un jeton AuthSub est requis.

Afficher 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 établit 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 next (suivante) : URL vers laquelle Google redirigera l'utilisateur une fois que l'utilisateur s'est connecté à son compte et a 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
une 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 ou non échangé contre un jeton de session ou non (true dans l'exemple ci-dessus)

OAuth pour le Web ou pour les applications installées/mobiles

OAuth peut être utilisé à la place d'AuthSub et est destiné aux applications Web. OAuth s'apparente au 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 vous devez enregistrer votre domaine.

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

Extraire un jeton de requête

Consultez la page Utiliser OAuth avec les bibliothèques clientes des API Google Data.

Autoriser un jeton de requête

Consultez la page Utiliser OAuth avec les bibliothèques clientes des API Google Data.

Passer à un jeton d'accès

Consultez la page Utiliser OAuth avec les bibliothèques clientes des 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 des comptes Google. À la première exécution, votre application invite l'utilisateur à saisir son nom d'utilisateur/mot de passe. Dans les requêtes suivantes, un jeton d'authentification est référencé.

Afficher les instructions pour intégrer ClientLogin à votre application installée

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

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

Conseil: Une fois que l'application a authentifié l'utilisateur pour la première fois, stockez le jeton d'authentification dans votre base de données pour le rappeler pour une utilisation ultérieure. Il n'est pas nécessaire de demander à l'utilisateur son mot de passe à chaque exécution de l'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 la page Utiliser ClientLogin avec les bibliothèques clientes des API Google Data.

Haut de page

Flux d'actualisation

Ce flux permet de répertorier les sites Google appartenant à un utilisateur ou pour lesquels il dispose d'autorisations de consultation. Elle peut également être utilisée pour modifier le nom d'un site existant. Pour les domaines G Suite, il permet également de créer et/ou de copier l'intégralité d'un site.

Répertorier les sites

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

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 et le nom du site, ainsi que son thème. D'autres getters sont disponibles pour accéder à d'autres propriétés 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 du site.

Cet exemple crée un site avec le thème "ardoise" (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ésente comme suit : https://sites.google.com/a/example.com/titre-de-mon-site.

Si le site a bien été créé, le serveur renvoie un objet SiteEntry contenant des éléments ajoutés par le serveur: un lien vers le site, un lien vers le flux LCA du site, le nom du site, le titre, le résumé, etc.

Copie d'un site

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

Copier un site revient à créer un site. La différence est que vous devez définir sur votre nouveau SiteEntry un lien comprenant le lien auto du site à dupliquer. Voici un exemple de duplication du site créé dans la section Création de 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 modèles de site appartenant à l'utilisateur authentifié peuvent être copiés.
Un modèle de site peut également être copié. Un site est considéré comme un modèle si le paramètre "Publier ce site comme modèle" est coché sur la page des paramètres de Google Sites.
Vous pouvez copier un site à partir d'un autre domaine, tant que vous n'êtes pas listé en tant que propriétaire sur le site source.

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

Pour renommer un site, ou en modifier le thème, la balise de catégorie ou le 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 de mapper 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'emplacement où votre site est hébergé, vous pouvez modifier manuellement le mappage des adresses Web. 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 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'afficheront 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 lors de l'utilisation des mappages d'adresses Web. Si le paramètre est absent, les webAddressMapping 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 de leurs métadonnées. Le paramètre with-mappings=true doit être inclus dans l'URI du flux de site. Remarque: Pour mettre à jour les mappages d'adresses, vous devez être administrateur du site ou du 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 http://www.mysitemapping2.com en laissant le lien 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 les mappages d'adresses Web peuvent également être spécifiés au moment de la création ou de la copie d'un site.

Haut de page

Flux d'activités

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

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

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 un collaborateur ou un propriétaire du site. Votre client doit s'authentifier à l'aide d'un jeton AuthSub, OAuth ou ClientLogin. Consultez la section Authentification 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 extrait 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 un collaborateur ou un propriétaire du site. Votre client doit s'authentifier à l'aide d'un jeton AuthSub, OAuth ou ClientLogin. Consultez la section Authentification auprès du service Sites.

Haut de page

Flux de contenu

Récupérer le flux de contenu

Le flux de contenu liste le contenu le plus récent 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

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

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 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 un 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:Ce flux peut nécessiter une authentification, 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 sur le service Sites.

Exemples de requêtes pour le 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'API de la version classique de Sites. Pour obtenir des informations plus détaillées et 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() de la section Récupérer le flux de contenu.

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

Pour récupérer uniquement 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 les valeurs 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 particulière. L'exemple suivant renvoie 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 de l'avoir défini dans le client.
client.site = "siteName";

Vous pouvez créer du contenu (pages Web, de listes, de classeurs, d'annonces, etc.) en envoyant 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 nouveau webpage sous le premier niveau 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 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 serait créé sous l'URL http://sites.google.com/site/siteName/new-webpage-title et aurait l'en-tête de page "Nouveau titre de la 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 l'en-tête "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 de l'URL d'une page:

<sites:pageName>, le cas échéant. 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 à rogner et réduire les espaces blancs en "-" 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 parente, vous devez définir le lien parent dans l'entrée. L'attribut href du lien au 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 du flux de contenu de l'utilisateur. Le titre de l'annonce est défini sur "Party !!" et le contenu sur "Ma place, 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 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 l'attribut rel='http://schemas.google.com/sites/2008#template' renvoyant vers le lien auto d'un modèle de page.

Dans cet exemple, un modèle filecabinet est créé, puis une page filecabinet est instanciée à 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>, il est toujours nécessaire d'en inclure un dans votre entrée. Notez également que si vous incluez un élément <content>, le serveur le refusera.

Importation des fichiers...

Tout comme dans Google Sites, l'API permet d'importer des pièces jointes vers un classeur ou une page parent.

Pour importer une pièce jointe dans 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. Par conséquent, vous devez définir un lien parent sur l'objet AttachmentEntry ou WebAttachmentEntry que vous essayez d'importer. Pour en savoir plus, consultez la section Créer des sous-pages.

Importation des pièces jointes…

Dans cet exemple, un fichier PDF est importé dans le premier FileCabinetPageEntry trouvé dans le flux de contenu de l'utilisateur. La pièce jointe est créée avec le titre "Getting Started" et la description (facultative) "HR package" (paquet de ressources humaines).

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 la pièce jointe créée.

Importer une pièce jointe dans un dossier

Pour importer une pièce jointe dans un dossier existant dans un FileCabinetPageEntry, incluez une catégorie dans laquelle l 'attribut "term" est défini sur le nom du dossier. Par exemple, ajoutez la ligne suivante 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. Ce sont pour l'essentiel des liens vers d'autres fichiers sur le Web que vous pouvez ajouter à vos listes de classeurs. 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 classeur. Elles ne peuvent pas être importées 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 respectivement sur "GoogleLogo" et "jolies 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 classeur de l'utilisateur qui pointe vers l'image sur "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 (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 HTTP PUT 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 a été remplacé par le terme "<p>Contenu HTML mis à jour</p>".
Le premier en-tête de 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!");

Modification du contenu des fichiers en 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.

L'exemple suivant 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. L'élément AttachmentEntry renvoyé inclut 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(). Si vous ne pouvez mettre à jour que 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 actualisée et le contenu du fichier est remplacé par un nouveau fichier .zip. Étant donné que la requête inclut du 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

Suppression du contenu

Pour supprimer une page ou un élément d'un site Google, commencez par récupérer 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 une réponse HTTP 200 OK.

Haut de page

Téléchargement 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 LCA

Présentation des autorisations de partage (LCA)

Chaque entrée de la LCA du flux LCA représente un rôle d'accès accordé à une entité spécifique : un utilisateur, un groupe d'utilisateurs, un domaine ou 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 seule entrée est affichée pour chaque adresse e-mail dans le panneau "Personnes disposant d'un accès" sur l'écran de partage de l'interface utilisateur de Google Sites. Ainsi, les administrateurs de domaine ne seront pas affichés, même s'ils ont un accès implicite à un site.

Rôles

L'élément de rôle représente un niveau d'accès qu'une entité peut avoir. Quatre valeurs sont possibles pour l'élément gAcl:role:

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

Niveaux d'accès

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

utilisateur : valeur d'adresse e-mail, par exemple "utilisateur@gmail.com".
group : adresse e-mail d'un groupe Google (par exemple, "groupe@domaine.com").
domaine : nom de domaine G Suite, par exemple "domaine.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 particulier contrôle l'accès de tout utilisateur par défaut sur un site public.

Remarque: Les domaines ne peuvent pas avoir de 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 LCA

Les classes AclFeed et AclEntry peuvent être utilisées pour contrôler les autorisations de partage d'un site et 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 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 dans le flux SiteFeed, chaque SiteEntry contient un lien vers son flux LCA. Par exemple, l'extrait suivant 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 pour les domaines G Suite est activé, etc.).

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

Voici un exemple où "user@example.com" est ajouté 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 des flux LCA pour connaître les valeurs AclScope et AclRoles possibles.

Partage au niveau du groupe et du domaine

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

Partage avec une adresse e-mail de groupe:

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

Partage avec un domaine entier:

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/domaine1.com/siteA ne peut partager l'intégralité du site qu'avec domaine1.com, et non avec domaine2.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 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 remplaçant "utilisateur@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.

Suppression des autorisations de partage

Pour supprimer une autorisation de partage, commencez par récupérer 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

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é, vous pouvez améliorer l'efficacité en indiquant au serveur de n'envoyer la liste ou l'entrée que si elle a été modifiée 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 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 celui 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 ETag ne correspondent pas, cela signifie que l'élément a été modifié depuis la dernière fois que vous l'avez demandé et que le serveur le renvoie.

Pour en savoir plus sur les ETag, 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

Authentification dans l'API Google 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 le Web ou pour les applications installées/mobiles

Extraire 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

Répertorier les sites

Créer des sites

Copie d'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 le flux de contenu

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

Récupérer une page par 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

Importation des fichiers...

Importation des pièces jointes…

Importer une pièce jointe dans un dossier

Pièces jointes Web

Mettre à jour le contenu

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

Modification du contenu des fichiers en pièce jointe

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

Suppression du contenu

Téléchargement des pièces jointes

Flux LCA

Présentation des autorisations de partage (LCA)

Rôles

Niveaux d'accès

Récupérer le flux LCA

Partager un site

Partage au niveau du groupe et du domaine

Modifier les autorisations de partage

Suppression des autorisations de partage

Sujets spéciaux

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