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. Options d'authentification décrits dans ce document (OAuth 1.0, AuthSub et ClientLogin) ont été officiellement abandonné 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 fournir des informations générales sur les fonctionnalités de l'API Sites Data, ce guide fournit des exemples d'interaction avec l'API. à l'aide de la bibliothèque cliente Java ; Si vous avez besoin d'aide pour configurer la bibliothèque cliente, consultez Premiers pas avec la bibliothèque cliente Java Google Data Si vous êtes intéressé par 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 Google Sites, consultez la guide du protocole.

Audience

Ce document est destiné aux développeurs qui souhaitent développer 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 êtes prêt. 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échargez 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épendances (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 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.

S'authentifier auprès de 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 à des données privées et publiques flux, en fonction d'une autorisation Sites et de l'opération que vous essayez d'effectuer. Par exemple, vous pouvez lire le flux de contenu un site public, mais ne pas le mettre à jour, ce qui nécessiterait un client authentifié. Pour ce faire, utilisez 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 le protocole 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 pour les domaines G Suite, le protocole SSL obligatoire du panneau de configuration administratif est respecté par l'API. Vous pouvez tout forcer les requêtes API doivent passer par 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 de 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. Il lui suffit Veuillez indiquer un jeton AuthSub.

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 dirigeant l'utilisateur à la page d'approbation AuthSub pour authentifier l'utilisateur et lui demander l'accès à ses documents. La bibliothèque cliente Java Google Data fournit une fonction 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 redirigera les internautes) 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
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 le Web ou les applications installées/mobiles

OAuth peut être utilisé à la place d'AuthSub et est destiné aux applications Web. OAuth revient à utiliser le mode enregistré et sécurisé d'AuthSub. car toutes les demandes 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

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 la page Utiliser OAuth avec les bibliothèques clientes de l'API Google Data.

Passer à un jeton d'accès

Consultez la page 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. Dans les requêtes ultérieures, 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, qui est héritée de GoogleService Indiquez 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 votre application a authentifié l'utilisateur pour la première fois, stockez le jeton d'authentification dans votre de base de données afin de la rappeler pour une utilisation ultérieure. 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 la page Utiliser ClientLogin avec les bibliothèques clientes de l'API Google Data.

Haut de page

Flux d'actualisation

Le flux de sites peut être utilisé pour répertorier les sites Google Sites d'un utilisateur ou pour lesquels il dispose d'autorisations d'affichage. 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 copier un l'intégralité du site.

Répertorier les sites

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

Création de sites

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

Pour provisionner de nouveaux sites, créez un SiteEntry et appelez la méthode insert() dans le flux du site.

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

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

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

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

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

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

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

La demande 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 a bien été créé, le serveur renvoie une réponse SiteEntry contenant les éléments ajoutés par le serveur: un lien vers le site, un lien vers le flux des 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 est semblable à la création d'un nouveau site. La différence est que vous devez définir sur votre nouveau SiteEntry, qui inclut le lien auto du 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 site appartenant à l'utilisateur authentifié peuvent être copiés.
Un modèle de site peut également être copié. Un site est utilisé comme modèle si la case "Publier ce site comme modèle" est coché 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 ou modifier son thème, sa balise de catégorie ou son résumé, vous devez d'abord extraire le fichier 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

Le mappage d'adresses Web permet aux utilisateurs de Sites de mapper leurs propres domaines sur un site Google. 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 un les mappages d'adresses Web du site. Pour en savoir plus, consultez notre article du Centre d'aide.

Extraire 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 mappages existants s'afficheront en tant que 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 les 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 Mettre à jour les métadonnées d'un site 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 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 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 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 (modifications) d'un site en récupérant le flux d'activités. Chaque entrée de la colonne le flux d'activités 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 une requête HTTP GET au lien de révision de l'entrée:

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

Cet exemple interroge le flux de contenu, puis récupère le flux de ré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 présente le contenu le plus récent 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 du 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 figurant 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 autre page ou un autre élément du site de l'utilisateur. Le ContentFeed contiendra différents types des objets, tous hérités de BaseContentEntry: ListItemEntry, ListPageEntry, AttachmentEntry, WebAttachmentEntry, FileCabinetPageEntry, AnnouncementsPageEntry, AnnouncementEntry, WebPageEntry et 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 elles ne sont pas toutes affiché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 ou non une authentification. selon les 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. Voir S'authentifier auprès du service Sites

Exemples de requêtes de flux de contenu

Vous pouvez effectuer une recherche dans le flux de contenu à l'aide de certains paramètres de requête standards de l'API Google Data. et celles spécifiques à l'API Google Sites classique. Pour obtenir des informations plus détaillées et la liste complète des paramètres pris en charge, consultez la 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 genres 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 filecabinet et listpage entrées:

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 relatif d'une page du site Google, vous pouvez utiliser le paramètre path pour explorer cette page en particulier. Cet exemple renverrait la page située à l'adresse http://sites.google.com/site/siteName/path/to/the/page:

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

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

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

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

Pour en savoir plus sur les autres paramètres, consultez le guide de référence.

Haut de page

Création de contenu

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

Vous pouvez créer du contenu (pages Web, pages de listes, 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 compatibles, consultez le paramètre kind dans le guide de référence.

Création de nouveaux éléments / pages

Cet exemple crée un nouvel élément webpage sous l'élément de premier niveau du site, en incluant 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 articles/pages sous des chemins d'URL personnalisées

Par défaut, l'exemple précédent est créé sous l'URL http://sites.google.com/site/siteName/new-webpage-title et avoir pour en-tête "Nouveau titre de la page Web". Autrement dit, pour l'URL, <atom:title> est normalisé en new-webpage-title. Pour personnaliser le chemin de 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 crée la page sous l'URL http://sites.google.com/site/siteName/files (au lieu de http://sites.google.com/site/siteName/file-storage) en spécifiant l'élément <sites:pageName>.

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

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

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

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

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

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

<sites:pageName>, le cas échéant. Doit respecter les a-z, A-Z, 0-9, -, _.
<atom:title>, ne doit pas être null si pageName n'est pas présent. La normalisation consiste à supprimer et réduire les espaces blancs sur "-" 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 nouveau announcement sous la première page d'annonces qui se trouve dans le flux de contenu de l'utilisateur. Le titre de l'annonce est défini sur "Party!!". et le contenu sur "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 identique à celui de création d'éléments/de pages et création de sous-pages. La différence réside dans l'ajout du category avec le terme et l'étiquette 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' pointer du doigt au lien auto d'un modèle de page.

Cet exemple crée un modèle filecabinet, puis instancie une nouvelle 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 élément <category>, y compris un élément dans votre est toujours obligatoire. Notez également que si vous incluez un élément <content>, le serveur le refusera.

Importer des fichiers

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

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. Vous devez donc définir un lien parent sur AttachmentEntry. ou WebAttachmentEntry que vous essayez d'importer. Pour en savoir plus, consultez la section Créer des sous-pages.

Transfert de pièces jointes

Cet exemple importe un fichier PDF dans le premier élément FileCabinetPageEntry trouvé dans le flux de contenu de l'utilisateur. La pièce jointe est créée avec le titre "Getting Started" (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 de pièce jointe créée.

Importation d'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 le terme "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 particuliers. Ce sont des liens vers d'autres fichiers sur le Web que vous pouvez ajouter à vos listes de fichiers. Cette fonctionnalité est semblable à "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 élément WebAttachmentEntry sous le premier élément FileCabinetPageEntry trouvé dans le flux de contenu de l'utilisateur. Son titre et sa description (facultative) sont définis sur "GoogleLogo". et « jolies couleurs », respectivement.

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

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

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

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

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

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

Haut de page

Mise à jour du contenu

Mise à jour des métadonnées et/ou du contenu HTML d'une page

Les métadonnées (titre, pageName, etc.) et le contenu de la page de n'importe quel type de BaseContentEntry peuvent être modifiés en à l'aide de la méthode update() de l'entrée. Une requête HTTP PUT sera alors envoyée au edit de l'entrée .

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

Le titre est remplacé par "Titre mis à jour".
Le contenu HTML de la page est mis à jour vers <p>Mise à jour du contenu HTML</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!");

Mise à jour du contenu de la pièce jointe...

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

L'exemple suivant permet de mettre à 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. La valeur renvoyée AttachmentEntry contiendra le contenu mis à jour.

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

Vous pouvez mettre à jour les métadonnées et le contenu d'une pièce jointe dans le même appel à l'aide de la méthode updateMedia(). Vous pouvez mettre à jour 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 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 de 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 la fonction 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échargement des pièces jointes

Pour télécharger un AttachmentEntry, envoyez une requête HTTP GET au lien de contenu src 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 représente un rôle d'accès attribué à 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 s'affiche. pour chaque adresse e-mail indiquée dans la section "Personnes ayant accès" dans 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 du rôle représente le niveau d'accès qu'une entité peut avoir. L'élément gAcl:role peut avoir quatre valeurs:

reader : lecteur (équivalent de l'accès en lecture seule).
writer : collaborateur (équivalent à l'accès en lecture/écriture).
propriétaire : généralement l'administrateur du site (qui équivaut à 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".
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 contrôle l'accès par défaut à tout utilisateur sur un site public.

Remarque: Les domaines ne peuvent pas avoir de valeur gAcl:role. défini sur "owner" (propriétaire) accès, ils ne peuvent être que lecteurs ou rédacteurs.

Récupérer le flux LCA

Les classes AclFeed et AclEntry peuvent être utilisées pour contrôler le partage d'un site autorisations et peuvent être récupérées à 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 dans le SiteFeed, chaque SiteEntry contient un lien vers son flux 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 accorder ces 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 nouveau AclEntry et POST au serveur.

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

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

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

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

Consultez la section Présentation du flux LCA pour découvrir la AclScope possible. et AclRoles.

Partage au niveau du groupe et du domaine

De la même manière que pour partager un site avec un seul utilisateur, vous pouvez partager un site sur une groupe Google ou domaine G Suite.

Partage avec l'adresse e-mail d'un groupe:

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

Partage 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 peut seulement partager l'intégralité du site avec domain1.com, et non domain2.com. Les sites qui 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 une autorisation de partage existante sur un site, récupérez d'abord l'AclEntry en question, puis modifiez l'autorisation puis appeler la méthode update() de AclEntry pour modifier la LCA sur le serveur.

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

Suppression des autorisations de partage...

Pour supprimer une autorisation de partage, récupérez d'abord 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 déjà récupérés, vous pouvez gagner en efficacité en indiquant au serveur d'envoyer la liste ou l'entrée uniquement 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 acceptant 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 demande, il vérifie si l'élément demandé possède le même ETag que l'ETag que vous avez spécifié. Si les ETags correspondent, l'élément n'a pas changé et le serveur renvoie soit un L'exception HTTP 304 NotModifiedException est levée.

Si les ETag ne correspondent pas, cela signifie que l'élément a été modifié depuis votre dernière demande et que le serveur le renvoie.

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 auprès de 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 les applications 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

Répertorier les sites

Création de sites

Copie d'un site

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

Mappages d'adresses Web

Extraire 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 de flux de contenu

Récupérer des genres 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éation de nouveaux éléments / pages

Créer des articles/pages sous des chemins d'URL personnalisées

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

Importation d'une pièce jointe dans un dossier

Pièces jointes Web

Mise à jour du contenu

Mise à jour des métadonnées et/ou du contenu HTML d'une page

Mise à jour du contenu de la pièce jointe...

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

Suppression de 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

Modification des autorisations de partage

Suppression des autorisations de partage...

Sujets spéciaux

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