Java-Sprachleitfaden

Wichtig:Dieses Dokument wurde vor 2012 verfasst. Die in diesem Dokument beschriebenen Authentifizierungsoptionen (OAuth 1.0, AuthSub und ClientLogin) wurden am 20. April 2012 offiziell eingestellt und sind nicht mehr verfügbar. Wir empfehlen Ihnen, so schnell wie möglich zu OAuth 2.0 zu migrieren.

Mit der Google Sites Data API können Client-Anwendungen auf Inhalte innerhalb einer Google Sites-Website zugreifen, diese veröffentlichen und ändern. Ihre Client-Anwendung kann auch eine Liste der letzten Aktivitäten anfordern, den Überarbeitungsverlauf abrufen und Anhänge herunterladen.

Neben Informationen zu den Funktionen der Sites Data API finden Sie in diesem Leitfaden auch Beispiele für die Interaktion mit der API mithilfe der Java-Clientbibliothek. Informationen zum Einrichten der Clientbibliothek finden Sie unter Erste Schritte mit der Google Data-Java-Clientbibliothek. Weitere Informationen zum zugrunde liegenden Protokoll, das von der Java-Clientbibliothek für die Interaktion mit der klassischen Sites API verwendet wird, finden Sie im Protokollleitfaden.

Zielgruppe

Dieses Dokument richtet sich an Entwickler, die mithilfe der Google Data-Java-Clientbibliothek Clientanwendungen erstellen möchten, die mit Google Sites interagieren.

Erste Schritte

In Google Sites werden Google-Konten oder G Suite-Konten zur Authentifizierung verwendet. Wenn Sie bereits ein Konto haben, sind Sie startklar. Andernfalls können Sie ein neues Konto erstellen.

Bibliothek installieren

Informationen zum Einrichten und Installieren der Clientbibliothek finden Sie unter Erste Schritte mit der Google Data-Java-Clientbibliothek. Wenn Sie Eclipse verwenden, wird in diesem Artikel auch erläutert, wie Sie Ihr Projekt mit dem Eclipse-Plug-in von Google Data APIs einrichten. Dafür benötigen Sie Folgendes:

1. Installieren Sie Java 1.5 oder höher.
2. Laden Sie die Clientbibliothek herunter (aktuelle Version von gdata-src.java.zip)
3. Liste der Abhängigkeiten herunterladen
4. Laden Sie die Beispielanwendungen herunter (die neueste Version von gdata-samples.java.zip).

Nach der Installation der JAR-Datei müssen Sie Folgendes in Ihr Projekt aufnehmen:

1. java/lib/gdata-sites-2.0.jar – Version 2.0 hier ist für Version 1.4 der klassischen Google Sites API bestimmt.
2. java/lib/gdata-core-1.0.jar
3. java/lib/gdata-client-1.0.jar
4. java/lib/gdata-spreadsheet-3.0.jar (wenn Sie mit Listenseiten / Listenelementen arbeiten)

Achten Sie auch darauf, die JAR-Dateien für Abhängigkeiten (gdata-media-1.0.jar, mail.jar und google-collect....jar) anzugeben.

Beispielanwendung ausführen

Eine voll funktionsfähige Beispielanwendung befindet sich im Unterverzeichnis /java/sample/sites des Downloads von gdata-samples.java.zip. Die Quelle ist auch unter /trunk/java/sample/sites/ im SVN-Repository verfügbar, auf das über den Tab „Quelle“ zugegriffen werden kann. Mit SitesDemo.java kann der Nutzer eine Reihe von Vorgängen ausführen, die zeigen, wie die klassische Google Sites API verwendet wird.

Hinweis: Sie müssen java/sample/util/lib/sample-util.jar angeben, um das Beispiel auszuführen.

Eigenes Projekt starten

Tipp: Informationen zur schnellen Einrichtung mit dem Eclipse-Plug-in finden Sie im Artikel Verwendung von Eclipse mit Google Data APIs.

Je nach den Anforderungen Ihrer Anwendung sind mehrere Importe erforderlich. Wir empfehlen, mit den folgenden Importen zu beginnen:

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.*;

Als Nächstes müssen Sie auch ein SitesService-Objekt einrichten, das eine Clientverbindung zur klassischen Google Sites API darstellt:

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

Das Argument applicationName muss das Format company-applicationname-version haben. Dieser Parameter wird für Logging-Zwecke verwendet.

Hinweis: Im weiteren Verlauf dieses Leitfadens wird davon ausgegangen, dass Sie eine SitesService in der Variablen client erstellt haben.

Bei der klassischen Google Sites API authentifizieren

Die Java-Clientbibliothek kann sowohl für öffentliche als auch für private Feeds verwendet werden. Die Sites Data API bietet Zugriff auf private und öffentliche Feeds, abhängig von den Sites-Berechtigungen und dem Vorgang, den Sie ausführen möchten. Sie können beispielsweise den Inhaltsfeed einer öffentlichen Website lesen, aber keine Aktualisierungen vornehmen. Dafür ist ein authentifizierter Client erforderlich. Dies kann über die ClientLogin-Authentifizierung mit Nutzername/Passwort, AuthSub oder OAuth erfolgen.

Weitere Informationen zu AuthSub, OAuth und ClientLogin finden Sie in der Authentifizierungsübersicht der Google Data APIs.

Tipp: Die API unterstützt SSL (HTTPS). Wenn Sie AuthSub/OAuth verwenden, müssen Sie den Bereich https://sites.google.com/feeds/ angeben, um Feeds über SSL anzufordern. Beachten Sie außerdem, dass bei G Suite-Domains die Einstellung "SSL erforderlich" im Administrator-Steuerfeld von der API berücksichtigt wird. Durch Aufrufen von client.useSsl(); können Sie erzwingen, dass alle API-Anfragen über HTTPS erfolgen.

AuthSub für Webanwendungen

Die AuthSub-Authentifizierung für Webanwendungen sollte von Clientanwendungen verwendet werden, die ihre Nutzer für Google-Konten authentifizieren müssen. Der Operator benötigt keinen Zugriff auf den Nutzernamen und das Passwort des Google Sites-Nutzers – nur ein AuthSub-Token ist erforderlich.

import com.google.gdata.client.*;

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

import com.google.gdata.client.*;

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

OAuth für Web-Apps oder installierte/mobile Anwendungen

OAuth kann als Alternative zu AuthSub verwendet werden und ist für Webanwendungen vorgesehen. OAuth ähnelt der Verwendung des sicheren und registrierten Modus von AuthSub insofern, als alle Datenanfragen digital signiert sein müssen und Sie Ihre Domain registrieren müssen.

ClientLogin für installierte/mobile Anwendungen

ClientLogin sollte von installierten oder mobilen Anwendungen verwendet werden, die ihre Nutzer für Google-Konten authentifizieren müssen. Bei der ersten Ausführung wird der Nutzer von der Anwendung zur Eingabe seines Nutzernamens und Passworts aufgefordert. Bei nachfolgenden Anfragen wird auf ein Authentifizierungstoken verwiesen.

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

Nach oben

Website-Feed

Im Website-Feed können die Google Sites-Websites aufgelistet werden, die einem Nutzer gehören oder für die er eine Anzeigeberechtigung hat. Es kann auch verwendet werden, um den Namen einer vorhandenen Website zu ändern. Bei G Suite-Domains kann damit auch eine gesamte Website erstellt und/oder kopiert werden.

Websites auflisten

Senden Sie zum Abfragen des Website-Feeds eine HTTP-GET-Anfrage an die Website-Feed-URL:

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

Im Java-Client können Sie die Klassen SiteFeed und SiteEntry verwenden, um mit dem Websitefeed zu arbeiten:

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

Mit dem Snippet oben werden der Titel, der Name und das Design der Website gedruckt. Für den Zugriff auf zusätzliche Properties im Feed stehen andere Getter zur Verfügung.

Neue Websites erstellen

Hinweis: Diese Funktion ist nur für G Suite-Domains verfügbar.

Neue Websites können bereitgestellt werden, indem eine neue SiteEntry erstellt und die Methode insert() des Clients im Websitefeed aufgerufen wird.

In diesem Beispiel wird eine brandneue Website mit dem Thema „Slate“ (optional) erstellt und der Websitename (erforderlich) und eine Beschreibung (optional) angegeben:

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

Mit dieser Anfrage wird eine neue Website unter der G Suite-Domain example.com erstellt. Die URL der Website lautet also https://sites.google.com/a/beispiel.de/titel_meiner-website.

Wenn die Website erfolgreich erstellt wurde, gibt der Server ein SiteEntry-Objekt zurück, das mit Elementen gefüllt ist, die vom Server hinzugefügt wurden: ein Link zur Website, ein Link zum ACL-Feed der Website, der Websitename, der Titel, eine Zusammenfassung usw.

Websites kopieren

Hinweis: Diese Funktion ist nur für G Suite-Domains verfügbar.

Das Kopieren einer Website ähnelt dem Erstellen einer neuen Website. Der Unterschied besteht darin, dass Sie in Ihrem neuen SiteEntry einen Link festlegen müssen, der den Self-Link der zu duplizierenden Website enthält. Hier ist ein Beispiel für das Duplizieren der Website, die im Abschnitt Neue Websites erstellen erstellt wurde:

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

Wichtige Punkte:

• Nur Websites und Websitevorlagen, die dem authentifizierten Nutzer gehören, können kopiert werden.
• Eine Websitevorlage kann auch kopiert werden. Eine Website ist eine Vorlage, wenn die Einstellung „Diese Website als Vorlage veröffentlichen“ auf der Seite mit den Google Sites-Einstellungen aktiviert ist.
• Solange Sie als Inhaber auf der Quellwebsite aufgeführt sind, können Sie Websites aus einer anderen Domain kopieren.

Metadaten einer Website aktualisieren

Wenn Sie eine Website umbenennen, ihr Design, ihr Kategorie-Tag oder ihre Zusammenfassung ändern möchten, müssen Sie zuerst die SiteEntry mit der betreffenden Website abrufen, eine oder mehrere Eigenschaften ändern und dann die Methode update() des SiteEntry aufrufen. In diesem Beispiel wird das Design der vorherigen Website geändert und die Website umbenannt:

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

Zuordnungen von Webadressen

Mithilfe von Webadressen-Zuordnungen können Google Sites-Nutzer ihre eigenen Domains einer Google Sites-Website zuordnen. Beispielsweise kann http://www.mydomainsite.com anstelle von http://sites.google.com/a/domain.com/mysite verwendet werden. Je nachdem, wo Ihre Website gehostet wird, können Sie die Zuordnungen der Webadresse einer Website manuell ändern. Weitere Informationen findest du in diesem Hilfeartikel.

Zuordnungen der Webadresse einer Website abrufen

Wenn Sie die Zuordnungen der Webadresse für eine Website zurückgeben möchten, rufen Sie den Websiteeintrag oder ‐feed mit dem Parameter with-mappings=true ab:

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

Vorhandene Zuordnungen werden als link mit rel='webAddressMapping' angezeigt. Im obigen Beispiel gibt es beispielsweise drei webAddressMappings, die auf die Website http://sites.google.com/site/myOtherTestSite verweisen.

Zuordnungen von Webadressen ändern

Hinweis: Bei allen GET-/POST/PUT-Vorgängen muss der Parameter with-mappings=true angegeben werden, wenn Sie mit Webadressenzuordnungen arbeiten. Wenn der Parameter nicht vorhanden ist, werden webAddressMappings in Websiteeinträgen (GET) nicht zurückgegeben und beim Aktualisieren/Entfernen (PUT) von Zuordnungen aus einem Eintrag nicht berücksichtigt.

Wenn Sie eine Zuordnung hinzufügen, aktualisieren oder löschen möchten, geben Sie einfach einen solchen Link an, ändern oder entfernen Sie ihn beim Erstellen neuer Websites oder beim Aktualisieren der Metadaten einer Website. Der Parameter with-mappings=true muss im Website-Feed-URI enthalten sein. Hinweis: Um Adresszuordnungen zu aktualisieren, müssen Sie Websiteadministrator oder Domainadministrator (im Fall einer G Suite-gehosteten Website) sein.

In der folgenden Anfrage wird beispielsweise die http://www.mysitemapping.com-Zuordnung zu http://www.my-new-sitemapping.com aktualisiert und das http://www.mysitemapping2.com entfernt, indem der Link im Eintrag weggelassen wird:

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

Hinweis: Webadressen-Zuordnungen können auch beim Erstellen/Kopieren einer Website angegeben werden.

Nach oben

Aktivitätsfeed

Sie können die letzten Aktivitäten (Änderungen) einer Website abrufen, indem Sie den Aktivitätsfeed abrufen. Jeder Eintrag im Aktivitätsfeed enthält Informationen zu einer Änderung, die an der Website vorgenommen wurde.

Um den Aktivitätsfeed abzufragen, senden Sie eine HTTP-GET an die Aktivitätsfeed-URL:

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

Verwenden Sie im Java-Client die Klasse ActivityFeed, um ActivityEntry-Objekte zurückzugeben:

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

Hinweis: Sie müssen ein Mitbearbeiter oder Inhaber der Website sein, um auf diesen Feed zugreifen zu können. Ihr Client muss sich mit einem AuthSub-, OAuth- oder ClientLogin-Token authentifizieren. Weitere Informationen finden Sie unter Beim Sites-Dienst authentifizieren.

Nach oben

Überarbeitungsfeed

Um den Überarbeitungsverlauf eines Inhaltseintrags abzurufen, senden Sie eine HTTP-GET an den Überarbeitungslink des Eintrags:

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

In diesem Beispiel wird der Inhaltsfeed abgefragt und dann der Überarbeitungsfeed für den ersten Inhaltseintrag abgerufen:

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

Hinweis: Um auf diesen Feed zugreifen zu können, müssen Sie ein Mitbearbeiter oder Inhaber der Website sein. Ihr Client muss sich mit einem AuthSub-, OAuth- oder ClientLogin-Token authentifizieren. Weitere Informationen finden Sie unter Beim Sites-Dienst authentifizieren.

Nach oben

Inhaltsfeed

Content-Feed abrufen

Der Content-Feed enthält die neuesten Inhalte einer Website. Sie können darauf zugreifen, indem Sie eine HTTP-GET-Anfrage an die Content-Feed-URL senden:

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

Beispiel für das Abrufen des Content-Feeds:

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

Das resultierende contentFeed ist ein ContentFeed-Objekt, das die Antwort des Servers enthält. Jeder Eintrag von contentFeed steht für eine andere Seite oder ein anderes Element auf der Website des Nutzers. ContentFeed enthält verschiedene Objekttypen, die alle von BaseContentEntry übernommen wurden: ListItemEntry, ListPageEntry, AttachmentEntry, WebAttachmentEntry, FileCabinetPageEntry, AnnouncementsPageEntry, AnnouncementEntry, WebPageEntry, CommentEntry.

Hier ist ein Beispiel für das Auflisten der verschiedenen Arten von Einträgen in einer ContentFeed. Jeder Eintragstyp enthält verschiedene Eigenschaften, aber nicht alle werden hier gedruckt.

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

Hinweis: Für diesen Feed ist möglicherweise eine Authentifizierung erforderlich, je nach den Freigabeberechtigungen der Website. Wenn die Website nicht öffentlich ist, muss sich Ihr Client mithilfe eines AuthSub-, OAuth- oder ClientLogin-Tokens authentifizieren. Weitere Informationen finden Sie unter Beim Sites-Dienst authentifizieren.

Beispiele für Content-Feed-Suchanfragen

Sie können im Inhaltsfeed mit einigen der standardmäßigen Google Data API-Suchparameter sowie mithilfe von Parametern suchen, die für die klassische Google Sites API spezifisch sind. Ausführlichere Informationen und eine vollständige Liste der unterstützten Parameter finden Sie im Referenzhandbuch.

Hinweis: In den Beispielen in diesem Abschnitt wird die Methode buildContentFeedUrl() aus Abrufen des Inhaltsfeeds verwendet.

Bestimmte Eintragstypen abrufen

Verwenden Sie den Parameter kind, um nur einen bestimmten Eintragstyp abzurufen. In diesem Beispiel werden nur attachment-Einträge zurückgegeben:

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

Wenn Sie mehr als einen Eintragstyp zurückgeben möchten, trennen Sie die einzelnen kind durch ein „,“. In diesem Beispiel werden filecabinet- und listpage-Einträge zurückgegeben:

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

Seite über Pfad abrufen

Wenn Sie den relativen Pfad einer Seite innerhalb der Google Sites-Website kennen, können Sie diese Seite mithilfe des path-Parameters abrufen. In diesem Beispiel wird die Seite unter http://sites.google.com/site/siteName/path/to/the/page zurückgegeben:

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

Alle Einträge unter einer übergeordneten Seite abrufen

Wenn du die Inhaltseintrags-ID einer Seite kennst (z.B. „1234567890“ im folgenden Beispiel), kannst du mit dem Parameter parent alle untergeordneten Einträge abrufen (falls vorhanden):

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

Weitere Parameter finden Sie im Referenzhandbuch.

Nach oben

Inhalte erstellen

Hinweis: Bevor Sie Inhalte für eine Website erstellen, prüfen Sie, ob Sie Ihre Website im Client festgelegt haben.
client.site = "siteName";

Sie können neue Inhalte (Web-, Listen-, Ordner- oder Ankündigungsseiten) erstellen, indem Sie eine HTTP-POST an den Content-Feed senden:

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

Eine Liste der unterstützten Knotentypen finden Sie im Referenzhandbuch unter dem Parameter kind.

Neue Elemente / Seiten erstellen

In diesem Beispiel wird eine neue webpage unter der obersten Ebene der Website erstellt, enthält einige XHTML für den Seitentext und legt den Titel der Überschrift auf "Neuer Titel der Webseite" fest:

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

Wenn die Anfrage erfolgreich ist, enthält createdEntry eine Kopie des auf dem Server erstellten Eintrags.

Elemente/Seiten unter benutzerdefinierten URL-Pfaden erstellen

Das vorherige Beispiel würde standardmäßig unter der URL http://sites.google.com/site/siteName/new-webpage-title erstellt werden und die Seitenüberschrift „Neuer Webseitentitel“ haben. Das <atom:title> wird für die URL zu new-webpage-title normalisiert. Wenn du den URL-Pfad einer Seite anpassen möchtest, kannst du das <sites:pageName>-Element festlegen.

In diesem Beispiel wird eine neue filecabinet-Seite mit der Überschrift "File Storage" erstellt, die Seite jedoch unter der URL http://sites.google.com/site/siteName/files (anstelle von http://sites.google.com/site/siteName/file-storage) erstellt, indem das Element <sites:pageName> angegeben wird.

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

Der Server verwendet die folgenden Prioritätsregeln, um den URL-Pfad einer Seite zu benennen:

1. <sites:pageName>, falls vorhanden. Muss a-z, A-Z, 0-9, -, _ erfüllen.
2. <atom:title>, darf nicht null sein, wenn „pageName“ nicht vorhanden ist. Normalisierung besteht darin, Leerzeichen auf „-“ zu kürzen und zu minimieren und Zeichen zu entfernen, die nicht mit a-z, A-Z, 0-9, -, _ übereinstimmen.

Unterseiten erstellen

Um untergeordnete Seiten (untergeordnete Seiten) einer übergeordneten Seite zu erstellen, müssen Sie den übergeordneten Link im Eintrag festlegen. Das Attribut href des Links zum Self-Link des übergeordneten Knotens.

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

Im Beispiel oben wird eine neue announcement unter der ersten Ankündigungsseite im Inhaltsfeed des Nutzers erstellt. Der Titel der Ankündigung wird auf „Party!!“ und der Inhalt auf „Mein Ort, dieses Wochenende“ festgelegt.

Seitenvorlagen

Seitenvorlagen erstellen

Der Vorgang zum Erstellen einer Seitenvorlage entspricht dem Erstellen neuer Elemente/Seiten und dem Erstellen von Unterseiten. Der Unterschied besteht im Hinzufügen von category, wobei Begriff und Label jeweils auf "http://schemas.google.com/g/2005#template" bzw. "Vorlage" festgelegt sind.

In diesem Beispiel wird eine neue webpage-Vorlage erstellt.

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

Seiten aus einer Vorlage erstellen

Ähnlich wie beim Erstellen von Seitenvorlagen können Sie eine neue Seite aus einer Vorlage instanziieren, indem Sie ein <link> einfügen, das rel='http://schemas.google.com/sites/2008#template' auf den Self-Link einer Seitenvorlage verweist.

In diesem Beispiel wird eine neue filecabinet-Vorlage erstellt und dann eine neue filecabinet-Seite aus dieser Vorlage instanziiert.

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

Hinweis: Trotz einer Vorlage, in der eine <category> definiert wird, müssen Sie eine in Ihrem Eintrag angeben. Wenn du ein <content>-Element einfügst, wird es vom Server abgelehnt.

Dateien werden hochgeladen

Genau wie in Google Sites unterstützt die API das Hochladen von Anhängen auf Dateiablagenseite oder übergeordnete Seite.

Wenn Sie einen Anhang für einen übergeordneten Anhang hochladen möchten, senden Sie eine HTTP-POST-Anfrage an die Contentfeed-URL:

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

Alle Anhangstypen müssen auf eine übergeordnete Seite hochgeladen werden. Daher legen Sie einen übergeordneten Link für das AttachmentEntry- oder WebAttachmentEntry-Objekt fest, das Sie hochladen möchten. Weitere Informationen finden Sie unter Unterseiten erstellen.

Anhänge werden hochgeladen

In diesem Beispiel wird eine PDF-Datei in das erste FileCabinetPageEntry im Content-Feed des Nutzers hochgeladen. Der Anhang wird mit dem Titel „Erste Schritte“ und einer (optionalen) Beschreibung „HR-Paket“ erstellt.

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

Wenn der Upload erfolgreich war, enthält attachment eine Kopie des Eintrags für den erstellten Anhang.

Anhang in einen Ordner hochladen

Wenn Sie einen Anhang in einen vorhandenen Ordner in einem FileCabinetPageEntry hochladen möchten, fügen Sie eine Kategorie hinzu, bei der das Attribut „term“ auf den Namen des Ordners festgelegt ist. Fügen Sie beispielsweise diese Zeile in uploadAttachment() ein:

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

Webanhänge

Webanhänge sind spezielle Arten von Anhängen. Im Wesentlichen handelt es sich dabei um Links zu anderen Dateien im Web, die Sie Ihren Ordnerlisten hinzufügen können. Diese Funktion ist analog zur Upload-Methode "Datei per URL hinzufügen" in der Google Sites-Benutzeroberfläche.

Hinweis: Webanhänge können nur in einer Dateiablage erstellt werden. Sie können nicht auf andere Seitentypen hochgeladen werden.

In diesem Beispiel wird unter dem ersten FileCabinetPageEntry im Content-Feed des Nutzers ein WebAttachmentEntry erstellt. Für den Titel und die optionale Beschreibung sind „GoogleLogo“ bzw. „netten Farben“ festgelegt.

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

Das POST erstellt in der Dateiablage des Nutzers einen Link, der auf das Bild unter "http://www.google.com/images/logo.gif" verweist.

Nach oben

Inhalte aktualisieren

Metadaten und/oder HTML-Inhalte einer Seite aktualisieren

Die Metadaten (title, pageName usw.) und der Seiteninhalt eines beliebigen BaseContentEntry-Typs können mit der Methode update() des Eintrags bearbeitet werden. Dadurch wird eine HTTP-PUT-Anfrage an den edit-Link des Eintrags gesendet.

Im Folgenden finden Sie ein Beispiel für das Aktualisieren einer ListPageEntry mit den folgenden Änderungen:

• Der Titel wird in „Aktualisierter Titel“ geändert.
• Der HTML-Inhalt der Seite wird zu <p>Aktualisierter HTML-Inhalt</p> aktualisiert.
• Die erste Spaltenüberschrift der Liste wird in "Inhaber" geändert.

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

Inhalt der Anhangsdatei aktualisieren

Für AttachmentEntry können Sie den Inhalt auch aktualisieren, indem Sie die MediaSource des Eintrags festlegen und dann die updateMedia(boolean)-Methode des Eintrags verwenden.

In diesem Beispiel wird der Inhalt eines vorhandenen Anhangs aktualisiert:

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

Im Beispiel wird eine HTTP-PUT-Anfrage an den edit-media-Link des Eintrags gesendet. Die zurückgegebene AttachmentEntry enthält den aktualisierten Inhalt.

Metadaten und Inhalte von Anhängen werden aktualisiert

Sie können die Metadaten eines Anhangs und seinen Inhalt mit der Methode updateMedia() im selben Aufruf aktualisieren. Sie können nur den Dateiinhalt, die Metadaten oder beides aktualisieren.

In diesem Beispiel wird der Titel des Anhangs in „Neuer Titel“ geändert, seine Beschreibung aktualisiert und der Dateiinhalt durch eine neue ZIP-Datei ersetzt. Da die Anfrage neuen Dateiinhalt enthält, wird der updateMedia() von AttachmentEntry verwendet.

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

Nach oben

Inhalte löschen

Wenn Sie eine Seite oder ein Element von einer Google Sites-Website entfernen möchten, rufen Sie zuerst den Inhaltseintrag ab und rufen Sie dann delete() des Eintrags auf.

entry.delete();

Sie können auch die delete()-Methode der Dienstklasse verwenden, indem Sie den edit-Link und den ETag-Wert des Eintrags übergeben:

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

Wurde der Eintrag erfolgreich gelöscht, antwortet der Server mit der HTTP-Anfrage 200 OK.

Nach oben

Anhänge herunterladen

Um einen AttachmentEntry herunterzuladen, senden Sie eine HTTP-GET-Anfrage an den Content-src-Link des Eintrags.

In diesem Beispiel wird die erste AttachmentEntry im Inhaltsfeed des Nutzers in das Verzeichnis „/path/to/save/file/“ heruntergeladen:

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

Nach oben

ACL-Feed

Übersicht über Freigabeberechtigungen (ACLs)

Jeder ACL-Eintrag im ACL-Feed steht für eine Zugriffsrolle einer bestimmten Entität, entweder eines Nutzers, einer Gruppe von Nutzern, einer Domain oder dem Standardzugriff (eine öffentliche Website). Einträge werden nur für Entitäten mit explizitem Zugriff angezeigt. Auf dem Freigabebildschirm der Google Sites-Benutzeroberfläche wird im Bereich "Personen mit Zugriff" für jede E-Mail-Adresse ein Eintrag angezeigt. Daher werden Domainadministratoren nicht angezeigt, auch wenn sie impliziten Zugriff auf eine Website haben.

Rollen

Das Rollenelement stellt eine Zugriffsebene dar, die eine Entität haben kann. Für das Element gAcl:role gibt es vier mögliche Werte:

• reader – ein Betrachter (entspricht dem Lesezugriff).
• writer – ein Mitbearbeiter (entspricht dem Lese-/Schreibzugriff).
• owner: normalerweise der Administrator der Website (entspricht Lese-/Schreibzugriff)

Ebenen

Das Bereichselement stellt die Entität dar, die diese Zugriffsebene hat. Es gibt vier mögliche Typen des gAcl:scope-Elements:

• Nutzer: Ein E-Mail-Adresswert, z. B. „nutzer@gmail.com“.
• Gruppe: E-Mail-Adresse einer Google Groups-Gruppe, z. B. "gruppe@domain.com".
• domain: ein G Suite-Domainname, z. B. "domain.com".
• default: Es gibt nur einen möglichen Bereich vom Typ „default“, der keinen Wert hat (z. B. <gAcl:scope type="default">). Mit diesem speziellen Bereich wird der Zugriff gesteuert, den jeder Nutzer standardmäßig auf einer öffentlichen Website hat.

Hinweis: Für Domains kann der Wert gAcl:role nicht auf „Inhaber“ festgelegt sein. Sie können nur Leser oder Autoren sein.

ACL-Feed abrufen

Mit den Klassen AclFeed und AclEntry können Sie die Freigabeberechtigungen einer Website steuern. Sie können mit der Methode getFeed() der Dienstklasse abgerufen werden.

Im folgenden Beispiel wird der ACL-Feed für eine bestimmte Website abgerufen und die Berechtigungen der einzelnen AclEntry ausgegeben:

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

Wenn Sie mit Einträgen im SiteFeed arbeiten, enthält jede SiteEntry einen Link zum zugehörigen ACL-Feed. Mit diesem Snippet wird beispielsweise der ACL-Feed eines SiteEntry abgerufen:

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

Website freigeben

Hinweis: Bestimmte Freigabe-ACLs sind möglicherweise nur möglich, wenn die Domain entsprechend konfiguriert ist, z.B. wenn die Freigabe außerhalb der Domain für G Suite-Domains aktiviert ist usw.

Wenn Sie eine Google Sites-Website mithilfe der API freigeben möchten, muss Ihr Client eine neue AclEntry erstellen und mit POST auf den Server übertragen.

In diesem Beispiel wird „nutzer@beispiel.de“ als reader auf der Website hinzugefügt:

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

Im Abschnitt Übersicht über den ACL-Feed finden Sie die möglichen Werte für AclScope und AclRoles.

Freigabe auf Gruppen- und Domainebene

Ähnlich wie bei der Freigabe einer Website für einen einzelnen Nutzer können Sie eine Website für eine Google-Gruppe oder G Suite-Domain freigeben.

Freigabe für eine Gruppen-E-Mail-Adresse:

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

Freigabe für eine gesamte Domain:

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

Die Freigabe auf Domainebene wird nur für G Suite-Domains und nur für die Domain unterstützt, in der die Website gehostet wird. Beispielsweise kann http://sites.google.com/a/domain1.com/siteA nur die gesamte Website für domain1.com freigeben, nicht für domain2.com. Websites, die nicht auf einer G Suite-Domain gehostet werden (z.B. http://sites.google.com/site/siteB), können keine Domains einladen.

Freigabeberechtigungen ändern

Wenn Sie eine vorhandene Freigabeberechtigung für eine Website freigeben möchten, rufen Sie zuerst die betreffende AclEntry ab, ändern Sie die Berechtigung wie gewünscht und rufen Sie dann die Methode update() der AclEntry auf, um die ACL auf dem Server zu ändern.

In diesem Beispiel wird unser vorheriges aclEntry-Beispiel aus dem Bereich Website freigeben geändert. Dabei wird „nutzer@beispiel.de“ als writer (Mitbearbeiter) aktualisiert:

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

Weitere Informationen zu ETags finden Sie im Referenzhandbuch für Google Data APIs.

Freigabeberechtigungen werden entfernt

Wenn Sie eine Freigabeberechtigung entfernen möchten, rufen Sie zuerst das AclEntry ab und dann die zugehörige delete()-Methode:

aclEntry.delete();

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

Weitere Informationen zu ETags finden Sie im Referenzhandbuch für Google Data APIs.

Nach oben

Spezielle Themen

Feed oder Eintrag noch einmal abrufen

Wenn Sie einen zuvor abgerufenen Feed oder Eintrag abrufen möchten, können Sie die Effizienz verbessern, indem Sie den Server anweisen, die Liste oder den Eintrag nur dann zu senden, wenn er sich seit dem letzten Abruf geändert hat.

Für diese Art von bedingtem Abruf stellen die Methoden getFeed() und getEntry() ein zusätzliches Argument bereit, das einen ETag-Wert oder ein DateTime-Objekt für den If-Modified-Since-Header akzeptiert. Sie können über entry.getEtag() auf das ETag eines Eintrags zugreifen.

In diesem Beispiel wird ein bedingter Abruf für einen Eintrag auf einer Inhaltswebseite durchgeführt:

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

Wenn der Server diese Anfrage erhält, prüft er, ob das angeforderte Element dasselbe ETag wie das angegebene ETag hat. Wenn die ETags übereinstimmen, hat sich das Element nicht geändert und der Server gibt entweder die HTTP-Ausnahme 304 NotModifiedException aus.

Wenn die ETags nicht übereinstimmen, wurde das Element seit Ihrer letzten Anforderung geändert und der Server gibt das Element zurück.

Weitere Informationen zu ETags finden Sie im Referenzhandbuch für Google Data APIs.

Nach oben