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 Clientanwendungen auf Inhalte in 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.

Dieser Leitfaden bietet nicht nur einige Hintergrundinformationen zu den Funktionen der Sites Data API, sondern enthält auch Beispiele für die Interaktion mit der API über die Java-Clientbibliothek. Informationen zum Einrichten der Clientbibliothek finden Sie unter Erste Schritte mit der Java-Clientbibliothek für Google Daten. 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 Clientanwendungen schreiben möchten, die mit Google Sites über die Google Data Java-Clientbibliothek interagieren.

Erste Schritte

Für die Authentifizierung in Google Sites werden Google-Konten oder G Suite-Konten verwendet. Wenn Sie bereits ein Konto haben, sind Sie startklar. Andernfalls können Sie ein neues Konto erstellen.

Bibliothek installieren

Hilfe zur Einrichtung und Installation der Clientbibliothek finden Sie unter Erste Schritte mit der Google Data-Java-Clientbibliothek. Falls Sie Eclipse verwenden, wird in diesem Artikel auch erläutert, wie Sie Ihr Projekt mit dem Eclipse-Plug-in für Google Data APIs einrichten. Dazu benötigen Sie Folgendes:

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

Nachdem Sie die JAR-Dateien installiert haben, 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 vorgesehen.
2. java/lib/gdata-core-1.0.jar
3. java/lib/gdata-client-1.0.jar
4. java/lib/gdata-spreadsheet-3.0.jar (bei Verwendung von Listenseiten / Listenelementen)

Geben Sie außerdem die Abhängigkeits-JARs (gdata-media-1.0.jar, mail.jar und google-collect....jar) an.

Beispielanwendung ausführen

Eine vollständige funktionierende Beispielanwendung befindet sich im Unterverzeichnis /java/sample/sites des Downloads gdata-samples.java.zip. Die Quelle ist auch im SVN-Repository unter /trunk/java/sample/sites/ verfügbar. Sie können es über den Tab „Source“ aufrufen. Mit dem SitesDemo.java können Nutzer verschiedene Vorgänge ausführen, um zu demonstrieren, wie die klassische 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 unserem Eclipse-Plug-in finden Sie im Artikel Eclipse mit Google Data APIs verwenden.

Je nach 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 ein SitesService-Objekt einrichten, das eine Clientverbindung zur klassischen Sites API darstellt:

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

Das Argument applicationName muss das Format company-applicationname-version haben. Dieser Parameter wird zu Protokollierungszwecken verwendet.

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

Bei der klassischen Sites API authentifizieren

Die Java-Clientbibliothek kann sowohl mit öffentlichen als auch mit privaten Feeds verwendet werden. Die Sites Data API bietet Zugriff auf private und öffentliche Feeds, je nach den Berechtigungen für Websites und dem gewünschten Vorgang. So können Sie beispielsweise den Inhaltsfeed einer öffentlichen Website lesen, aber keine Änderungen daran vornehmen. Dafür ist ein authentifizierter Client erforderlich. Dies kann über die Nutzername/Passwort-Authentifizierung ClientLogin, AuthSub oder OAuth erfolgen.

Weitere Informationen zu AuthSub, OAuth und ClientLogin finden Sie in der Übersicht zur Authentifizierung bei 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 die Einstellung "SSL erforderlich" im Administrator-Steuerfeld für G Suite-Domains von der API berücksichtigt wird. Sie können alle API-Anfragen über HTTPS erzwingen, indem Sie client.useSsl(); aufrufen.

AuthSub für Webanwendungen

Die AuthSub-Authentifizierung für Webanwendungen sollte von Clientanwendungen verwendet werden, die ihre Nutzer in Google-Konten authentifizieren müssen. Der Operator benötigt keinen Zugriff auf den Nutzernamen und das Passwort für den Google Sites-Nutzer – 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- 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 werden 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 bei Google-Konten authentifizieren müssen. Beim ersten Start wird der Nutzer von Ihrer App aufgefordert, seinen Nutzernamen und sein Passwort einzugeben. 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 Websitefeed können die Google Sites aufgeführt werden, deren Inhaber ein Nutzer ist oder für die er Leseberechtigungen hat. Es kann auch verwendet werden, um den Namen einer vorhandenen Site zu ändern. Für G Suite-Domains kann damit auch eine ganze Website erstellt und/oder kopiert werden.

Websites auflisten

Senden Sie eine HTTP-GET-Anfrage an die Website-Feed-URL, um den Website-Feed abzufragen:

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

Im Java-Client kannst du 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("");
  }
}

Im obigen Snippet werden der Titel, der Name und das Design der Website ausgegeben. Es gibt weitere Getter, mit denen Sie auf weitere Properties im Feed zugreifen können.

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 Kunden im Websitefeed aufgerufen wird.

In diesem Beispiel wird eine ganz neue Website mit dem Thema „Slate“ (optionale Einstellung) erstellt. Außerdem werden der Name (erforderlich) und die Beschreibung (optional) der Website 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 der obigen Anfrage wird eine neue Website unter der G Suite-Domain example.com erstellt. Die URL der Website lautet dann https://sites.google.com/a/beispiel.de/meine-website-mit-titel.

Wenn die Website erfolgreich erstellt wurde, gibt der Server ein SiteEntry-Objekt zurück, das vom Server hinzugefügte Elemente enthält: einen Link zur Website, einen Link zum ACL-Feed der Website, den Namen der Website, den Titel, eine Zusammenfassung usw.

Website 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 Ihrer neuen SiteEntry einen Link mit dem Link zur Website einrichten müssen, die dupliziert werden soll. 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:

• Es können nur Websites und Website-Vorlagen kopiert werden, deren Inhaber der authentifizierte Nutzer ist.
• Eine Websitevorlage kann auch kopiert werden. Eine Website ist eine Vorlage, wenn die Einstellung "Diese Website als Vorlage veröffentlichen" in den Google Sites-Einstellungen aktiviert ist.
• Sie können eine Website aus einer anderen Domain kopieren, sofern Sie auf der Quellwebsite als Inhaber aufgeführt sind.

Metadaten einer Website aktualisieren

Wenn Sie eine Website umbenennen, das Thema, das Kategorie-Tag oder die Zusammenfassung ändern möchten, müssen Sie zuerst SiteEntry mit der betreffenden Website abrufen, mindestens ein Attribut bearbeiten und dann die Methode update() von 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();

Webadressenzuordnungen

Mit Webadressenzuordnungen können Google Sites-Nutzer ihre eigenen Domains einer Google-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 Webadressenzuordnungen einer Website manuell ändern. Weitere Informationen finden Sie in diesem Hilfeartikel.

Zuordnungen von Webadressen einer Website abrufen

Wenn Sie die Zuordnungen von Webadressen für eine Website zurückgeben möchten, rufen Sie den Websiteeintrag/-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 verweisen beispielsweise drei webAddressMappings auf die Website http://sites.google.com/site/myOtherTestSite.

Zuordnungen von Webadressen ändern

Hinweis: Bei allen GET/POST/PUT-Vorgängen muss bei Webadressenzuordnungen der Parameter with-mappings=true angegeben werden. Wenn der Parameter fehlt, werden webAddressMappings nicht in Websiteeinträgen zurückgegeben (GET) und nicht berücksichtigt, wenn Zuordnungen in einem Eintrag aktualisiert oder entfernt (PUT) werden.

Wenn Sie eine Zuordnung hinzufügen, aktualisieren oder löschen möchten, müssen Sie beim Erstellen neuer Websites oder beim Aktualisieren der Metadaten einer Website einfach einen solchen Link angeben, ändern oder entfernen. Der Parameter with-mappings=true muss in der URI des Website-Feeds enthalten sein. Hinweis: Um Adresszuordnungen zu aktualisieren, müssen Sie Website-Administrator oder bei einer von der G Suite gehosteten Website Domainadministrator sein.

Mit der folgenden Anfrage wird beispielsweise die http://www.mysitemapping.com-Zuordnung zu http://www.my-new-sitemapping.com aktualisiert und 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();

Webadressenzuordnungen können auch beim Erstellen oder 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.

Senden Sie zum Abfragen des Aktivitätsfeeds eine HTTP-GET-Anfrage 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 benötigen Zugriff als Mitbearbeiter oder Inhaber der Website, 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 Authentifizierung beim Sites-Dienst.

Nach oben

Feed mit Änderungen

Wenn du den Überarbeitungsverlauf für einen Inhaltseintrag abrufen möchtest, sende eine HTTP-GET an den Link zur Überarbeitung des Eintrags:

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

In diesem Beispiel wird der Content-Feed abgefragt und dann der Überarbeitungsfeed für den ersten Content-Eintrag 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: Sie benötigen Zugriff als Mitbearbeiter oder Inhaber der Website, 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 Authentifizierung beim Sites-Dienst.

Nach oben

Inhaltsfeed

Content-Feed abrufen

Der Content-Feed listet den neuesten Content einer Website auf. 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 vom Server 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 werden: ListItemEntry, ListPageEntry, AttachmentEntry, WebAttachmentEntry, FileCabinetPageEntry, AnnouncementsPageEntry, AnnouncementEntry, WebPageEntry, CommentEntry.

Hier ist ein Beispiel für die Auflistung der verschiedenen Arten von Einträgen in einer ContentFeed. Jeder Eintragstyp enthält unterschiedliche Eigenschaften, die hier jedoch nicht alle aufgeführt sind.

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, abhängig von den Freigabeberechtigungen der Website. Wenn die Website nicht öffentlich ist, muss sich Ihr Client mit einem AuthSub-, OAuth- oder ClientLogin-Token authentifizieren. Weitere Informationen finden Sie unter Authentifizierung beim Sites-Dienst.

Beispiele für Content-Feed-Abfragen

Sie können im Inhaltsfeed mit einigen der Standardabfrageparameter der Google Data API und denjenigen, die speziell für die klassische Sites API gelten, suchen. Weitere 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 Inhaltsfeed abrufen verwendet.

Bestimmte Arten von Einträgen abrufen

Wenn Sie nur einen bestimmten Eintragstyp abrufen möchten, verwenden Sie den Parameter kind. 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 Komma. 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 auf der Google-Website kennen, können Sie mit dem Parameter path diese Seite 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 Sie die Inhaltseintrags-ID einer Seite kennen (z. B. „1234567890“ im Beispiel unten), können Sie 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, müssen Sie die Website im Kundencenter eingerichtet haben.
client.site = "siteName";

Du kannst neue Inhalte (Webseiten, Listenseiten, Ordnerseiten, Ankündigungsseiten usw.) erstellen, indem du ein HTTP-POST an den Inhaltsfeed sendest:

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

Eine Liste der unterstützten Knotentypen finden Sie im Referenzhandbuch im Abschnitt zum Parameter kind.

Neue Elemente/Seiten erstellen

In diesem Beispiel wird eine neue webpage unter der obersten Ebene der Website erstellt, enthält XHTML für den Seitentext und legt den Titel der Überschrift auf „Neuer Webseitentitel“ 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 Eintrags, der auf dem Server erstellt wurde.

Elemente/Seiten unter benutzerdefinierten URL-Pfaden erstellen

Standardmäßig wird das vorherige Beispiel unter der URL http://sites.google.com/site/siteName/new-webpage-title erstellt und hat den Seitentitel „Neuer Seitentitel“. Das heißt, der <atom:title> wird für die URL auf new-webpage-title normalisiert. Wenn Sie den URL-Pfad einer Seite anpassen möchten, können Sie das Element <sites:pageName> festlegen.

In diesem Beispiel wird eine neue filecabinet-Seite mit der Überschrift „Dateispeicher“ erstellt. Die Seite wird 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 Vorrangregeln für die Benennung des URL-Pfads einer Seite:

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. Bei der Normalisierung werden Leerzeichen entfernt und auf „-“ zusammengezogen und Zeichen entfernt, die nicht mit a-z, A-Z, 0-9, -, _ übereinstimmen.

Unterseiten erstellen

Um untergeordnete Seiten unter einer übergeordneten Seite zu erstellen, müssen Sie den übergeordneten Link im Eintrag festlegen. Das href-Attribut des Links zum Selbstlink 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 Seite für Mitteilungen im Inhaltsfeed des Nutzers erstellt. Der Titel der Mitteilung lautet „Party!“ und der Inhalt „Bei mir, am Wochenende“.

Seitenvorlagen

Seitenvorlagen erstellen

Das Erstellen einer Seitenvorlage entspricht dem Erstellen neuer Elemente/Seiten und dem Erstellen von Unterseiten. Der Unterschied besteht darin, dass die category mit dem Begriff und dem Label „http://schemas.google.com/g/2005#template“ bzw. „template“ hinzugefügt wird.

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 erstellen, indem Sie einen <link> mit rel='http://schemas.google.com/sites/2008#template' einfügen, der auf den Link der 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: Es ist zwar eine Vorlage, mit der eine <category> definiert wird, weiterhin erforderlich, einschließlich einer Vorlage in Ihrem Eintrag. Wenn Sie ein <content>-Element angeben, wird es vom Server abgelehnt.

Dateien werden hochgeladen

Genau wie in Google Sites unterstützt die API den Upload von Anhängen auf die Seite der Dateiablage oder auf eine übergeordnete Seite.

Wenn Sie einen Anhang für ein übergeordnetes Element hochladen möchten, senden Sie eine HTTP-POST-Anfrage an die Content-Feed-URL:

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

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

Anhänge werden hochgeladen

In diesem Beispiel wird eine PDF-Datei in die erste FileCabinetPageEntry hochgeladen, die im Inhaltsfeed des Nutzers gefunden wird. Der Anhang wird mit dem Titel „Erste Schritte“ und der (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 ist, enthält attachment eine Kopie des erstellten Anhangseintrags.

Anhang in einen Ordner hochladen

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

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 um Links zu anderen Dateien im Web, die Sie Ihren Ordnerlisten hinzufügen können. Diese Funktion entspricht der Uploadmethode „Datei per URL hinzufügen“ in der Google Sites-Benutzeroberfläche.

Hinweis: Webanhänge können nur in einem Aktenschrank erstellt werden. Sie können nicht auf andere Arten von Seiten hochgeladen werden.

In diesem Beispiel wird ein WebAttachmentEntry unter dem ersten FileCabinetPageEntry erstellt, das im Inhaltsfeed des Nutzers gefunden wird. Der Titel und die (optionale) Beschreibung sind auf „GoogleLogo“ und „schöne 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!");

Der POST erstellt einen Link im Dateischrank des Nutzers, 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 Seiteninhalte eines beliebigen BaseContentEntry-Typs können mithilfe der update()-Methode des Eintrags bearbeitet werden. Dadurch wird eine HTTP-PUT-Anfrage an den edit-Link des Eintrags gesendet.

Im folgenden Beispiel wird eine ListPageEntry-Datei mit den folgenden Änderungen aktualisiert:

• Der Titel wurde in „Aktualisierter Titel“ geändert
• Der HTML-Inhalt der Seite wird in <p>Aktualisierter HTML-Inhalt</p> geändert.
• 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 Anhangdatei aktualisieren

Bei AttachmentEntry können Sie den Inhalt auch aktualisieren, indem Sie den MediaSource-Wert 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);
}

In diesem 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 aktualisieren

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

In diesem Beispiel wird der Titel des Anhangs in „Neuer Titel“ geändert, die Beschreibung aktualisiert und der Dateiinhalt durch eine neue ZIP-Datei ersetzt. Da die Anfrage neue Dateiinhalte enthält, wird die updateMedia() der 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 die delete() des Eintrags auf.

entry.delete();

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

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

Wenn der Eintrag erfolgreich gelöscht wurde, antwortet der Server mit einer HTTP-200 OK.

Nach oben

Anhänge herunterladen

Wenn du eine AttachmentEntry herunterladen möchtest, sende eine HTTP-GET-Anfrage an den Inhalts-SRC-Link des Eintrags.

In diesem Beispiel wird das erste AttachmentEntry, das im Inhaltsfeed des Nutzers gefunden wird, 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

Freigabeberechtigungen (ACLs) – Übersicht

Jeder ACL-Eintrag im ACL-Feed stellt eine Zugriffsrolle eines bestimmten Elements dar, entweder eines Nutzers, einer Gruppe von Nutzern, einer Domain oder des Standardzugriffs (eine öffentliche Website). Einträge werden nur für Entitäten mit explizitem Zugriff angezeigt. Auf dem Bildschirm „Teilen“ der Google Sites-Benutzeroberfläche wird im Bereich „Personen mit Zugriff“ jeweils ein Eintrag für jede E-Mail-Adresse angezeigt. Domainadministratoren werden also 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 Viewer (entspricht Lesezugriff).
• writer – ein Mitbearbeiter (entspricht Lese-/Schreibzugriff).
• owner – in der Regel der Websiteadministrator (entspricht Lese-/Schreibzugriff)

Ebenen

Das Element „scope“ stellt die Entität dar, die diese Zugriffsebene hat. Es gibt vier mögliche Typen von gAcl:scope-Elementen:

• user: E-Mail-Adresse, z. B. „user@gmail.com“.
• group – eine E-Mail-Adresse einer Google-Gruppe, z. B. „gruppe@domain.com“.
• domain: G Suite-Domainname, z. B. „domain.com“.
• default: Es gibt nur einen möglichen Gültigkeitsbereich vom Typ „default“, der keinen Wert hat (z. B. <gAcl:scope type="default">). Mit diesem Gültigkeitsbereich wird der Zugriff gesteuert, den alle Nutzer standardmäßig auf eine öffentliche Website haben.

Hinweis: Domains können keinen gAcl:role-Wert für den Zugriffstyp „Inhaber“ haben. Sie können nur Leser oder Schreiber sein.

ACL-Feed abrufen

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

Im folgenden Beispiel wird der ACL-Feed für eine bestimmte Website abgerufen und die Berechtigungen für jede 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 jeder SiteEntry einen Link zum entsprechenden ACL-Feed. Das folgende Snippet ruft beispielsweise den ACL-Feed eines SiteEntry ab:

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 ACLs für die Freigabe sind möglicherweise nur möglich, wenn die Domain so konfiguriert ist, dass solche Berechtigungen zulässig sind (z. B. wenn die Freigabe außerhalb der Domain für G Suite-Domains aktiviert ist).

Wenn Sie eine Google Sites-Website über die API freigeben möchten, muss Ihr Client ein neues AclEntry erstellen und mit POST auf den Server übertragen.

Hier siehst du ein Beispiel, bei dem „nutzer@beispiel.de“ als reader auf der Website hinzugefügt wird:

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 ACL-Feed – Übersicht finden Sie die möglichen Werte für AclScope und AclRoles.

Freigabe auf Gruppen- und Domainebene

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

Beim Teilen mit einer Gruppen-E-Mail-Adresse geschieht Folgendes:

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

Freigabe für eine ganze 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. Für Websites, die nicht in einer G Suite-Domain gehostet werden (z.B. http://sites.google.com/site/siteB), können keine Domains eingeladen werden.

Freigabeberechtigungen ändern

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

In diesem Beispiel wird das vorherige aclEntry-Beispiel aus dem Abschnitt Website freigeben geändert, indem „nutzer@beispiel.de“ in writer (Mitbearbeiter) geändert wird:

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 entfernen

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

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

Besondere Themen

Feed oder Eintrag noch einmal abrufen

Wenn Sie einen Feed oder Eintrag abrufen möchten, den Sie zuvor abgerufen haben, können Sie die Effizienz steigern, indem Sie den Server anweisen, die Liste oder den Eintrag nur zu senden, wenn sie sich seit dem letzten Abruf geändert haben.

Für diese Art des bedingten Abrufs bieten sowohl die getFeed()- als auch die getEntry()-Methode ein zusätzliches Argument, das einen ETag-Wert oder ein DateTime-Objekt für den If-Modified-Since-Header akzeptiert. Sie können über entry.getEtag() auf den 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 empfängt, wird geprüft, 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 304-Ausnahme NotModifiedException zurück.

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

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

Nach oben