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, sie veröffentlichen und ändern. Ihre Clientanwendung kann auch eine Liste der letzten Aktivitäten anfordern, den Überarbeitungsverlauf abrufen und Anhänge herunterladen.

In diesem Leitfaden werden nicht nur die Funktionen der Sites Data API erläutert, sondern auch Beispiele für die Interaktion mit der API mithilfe der Java-Clientbibliothek bereitgestellt. Hilfe beim Einrichten der Clientbibliothek finden Sie unter Erste Schritte mit der Google Data Java Client Library. Wenn Sie mehr über das zugrunde liegende Protokoll erfahren möchten, das von der Java-Clientbibliothek für die Interaktion mit der Classic Sites API verwendet wird, lesen Sie den Protokollleitfaden.

Zielgruppe

Dieses Dokument richtet sich an Entwickler, die Clientanwendungen schreiben möchten, die über die Google Data Java Client Library mit Google Sites interagieren.

Erste Schritte

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

Bibliothek installieren

Hilfe beim 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 beschrieben, wie Sie Ihr Projekt mit dem Google Data APIs Eclipse-Plug-in einrichten. Das benötigen Sie für den Einstieg:

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

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

  1. java/lib/gdata-sites-2.0.jar: Version 2.0 ist für Version 1.4 der klassischen 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 (wenn Sie mit Listenseiten oder Listenelementen arbeiten)

Achten Sie außerdem darauf, die Abhängigkeits-Jars (gdata-media-1.0.jar, mail.jar und google-collect....jar) einzufügen.

Beispielanwendung ausführen

Eine vollständige Beispielanwendung finden Sie im Unterverzeichnis /java/sample/sites des Downloads gdata-samples.java.zip. Der Quellcode ist auch im SVN-Repository unter /trunk/java/sample/sites/ 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 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: Im Artikel Using Eclipse with Google Data APIs finden Sie Informationen zur schnellen Einrichtung mit unserem Eclipse-Plug-in.

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 Sites API darstellt:

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

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

Hinweis: Im Rest dieser Anleitung wird davon ausgegangen, dass Sie eine SitesService in der Variablen client erstellt haben.

Bei der Classic 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, je nach den Berechtigungen für die jeweilige Google-Website und der Operation, die Sie ausführen möchten. So können Sie beispielsweise den Inhaltsfeed einer öffentlichen Website lesen, aber keine Aktualisierungen daran vornehmen. Dazu wäre ein authentifizierter Client erforderlich. Dies kann über die ClientLogin-Authentifizierung mit Nutzername und Passwort, 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 für G Suite-Domains die Einstellung „SSL erforderlich“ in der Admin-Konsole von der API berücksichtigt wird. Sie können erzwingen, dass alle API-Anfragen über HTTPS erfolgen, indem Sie client.useSsl(); aufrufen.

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 Betreiber benötigt keinen Zugriff auf den Nutzernamen und das Passwort des Google Sites-Nutzers, sondern nur ein AuthSub-Token.

Anleitung zum Einbinden von AuthSub in Ihre Webanwendung ansehen

Einmal-Token anfordern

Wenn der Nutzer Ihre Anwendung zum ersten Mal aufruft, muss er sich authentifizieren. Normalerweise geben Entwickler etwas Text und einen Link aus, der den Nutzer zur AuthSub-Genehmigungsseite weiterleitet, um den Nutzer zu authentifizieren und Zugriff auf seine Dokumente anzufordern. Die Google Data Java-Clientbibliothek bietet eine Funktion zum Generieren dieser URL. Mit dem folgenden Code wird ein Link zur Seite AuthSubRequest eingerichtet.

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

So authentifizieren Sie Nutzer in Ihrer in der G Suite gehosteten Domain:

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

Die Methode getRequestUrl() verwendet mehrere Parameter, die den von AuthSubRequest verwendeten Abfrageparametern entsprechen:

  • die next-URL – die URL, zu der Google weiterleitet, nachdem sich der Nutzer in seinem Konto angemeldet und Zugriff gewährt hat; http://www.example.com/welcome.jsp im Beispiel oben
  • Bereich – https://sites.google.com/feeds/ im obigen Beispiel
  • Ein boolescher Wert, der angibt, ob das Token im registrierten Modus verwendet wird. Im Beispiel oben ist das false.
  • einen zweiten booleschen Wert, der angibt, ob das Token später gegen ein Sitzungstoken eingetauscht wird oder nicht. Im Beispiel oben ist das true.

Auf ein Sitzungstoken upgraden

Weitere Informationen finden Sie unter AuthSub mit den Google Data API-Clientbibliotheken verwenden.

Informationen zu einem Sitzungstoken abrufen

Weitere Informationen finden Sie unter AuthSub mit den Google Data API-Clientbibliotheken verwenden.

Sitzungstoken widerrufen

Weitere Informationen finden Sie unter AuthSub mit den Google Data API-Clientbibliotheken verwenden.

OAuth für Web- oder installierte/mobile Anwendungen

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

Anleitung zum Einbinden von OAuth in Ihre installierte Anwendung aufrufen

Anfrage-Token abrufen

Weitere Informationen finden Sie unter OAuth mit den Google Data API-Clientbibliotheken verwenden.

Anfrage-Token autorisieren

Weitere Informationen finden Sie unter OAuth mit den Google Data API-Clientbibliotheken verwenden.

Auf ein Zugriffstoken upgraden

Weitere Informationen finden Sie unter OAuth mit den Google Data API-Clientbibliotheken verwenden.

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. Beim ersten Start fordert Ihre Anwendung den Nutzer auf, seinen Nutzernamen und sein Passwort einzugeben. Bei nachfolgenden Anfragen wird auf ein Authentifizierungstoken verwiesen.

Anleitung zum Einbinden von ClientLogin in Ihre installierte Anwendung aufrufen

Wenn Sie ClientLogin verwenden möchten, rufen Sie die Methode setUserCredentials() des SitesService-Objekts auf, die von GoogleService übernommen wird. Geben Sie die E-Mail-Adresse und das Passwort des Nutzers an, in dessen Namen Ihr Client Anfragen stellt. Beispiel:

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

Tipp: Nachdem Ihre Anwendung den Nutzer zum ersten Mal erfolgreich authentifiziert hat, speichern Sie das Authentifizierungstoken in Ihrer Datenbank, um es später wieder abrufen zu können. Der Nutzer muss nicht bei jedem Ausführen Ihrer Anwendung nach seinem Passwort gefragt werden. Weitere Informationen finden Sie unter Autorisierungstoken zurückrufen.

Weitere Informationen zur Verwendung von ClientLogin in Ihren Java-Anwendungen finden Sie unter ClientLogin mit den Google Data API-Clientbibliotheken verwenden.

Nach oben

Website-Feed

Mit dem Websitefeed können die Google Sites aufgelistet werden, die einem Nutzer gehören oder für die er die Berechtigung zum Ansehen hat. Sie kann auch verwendet werden, um den Namen einer bestehenden Website zu ändern. Bei G Suite-Domains kann damit auch eine gesamte Website erstellt und/oder kopiert werden.

Websites auflisten

Wenn Sie den Websitefeed abfragen möchten, senden Sie eine HTTP-GET-Anfrage an die Websitefeed-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("");
  }
}

Im obigen Snippet werden der Titel der Website, der Name der Website und das Design der Website ausgegeben. Für den Zugriff auf zusätzliche Eigenschaften im Feed sind weitere Getter verfügbar.

Neue Websites erstellen

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

Neue Websites können bereitgestellt werden, indem Sie ein neues SiteEntry erstellen und die insert()-Methode des Clients für den Websitefeed aufrufen.

In diesem Beispiel wird eine neue Website mit dem Design „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 wäre also https://sites.google.com/a/beispiel.de/mein-websitetitel.

Wenn die Website erfolgreich erstellt wurde, antwortet der Server mit einem SiteEntry-Objekt, das mit vom Server hinzugefügten Elementen gefüllt ist: einem Link zur Website, einem Link zum ACL-Feed der Website, dem Namen der Website, dem Titel, der 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 einen Link für die neue SiteEntry festlegen müssen, der den Selbstlink 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:

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

Metadaten einer Website aktualisieren

Wenn Sie eine Website umbenennen, ihr Design, ihr Kategorie-Tag oder ihre Zusammenfassung ändern möchten, müssen Sie zuerst SiteEntry mit der betreffenden Website abrufen, eine oder mehrere Eigenschaften ändern und dann die update()-Methode von SiteEntry aufrufen. In diesem Beispiel wird das Design der vorherigen Website geändert und die Website wird 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();

Webadresszuordnungen

Mit der Zuordnung von Webadressen können Sites-Nutzer ihre eigenen Domains einer Google-Website zuordnen. http://www.mydomainsite.com kann beispielsweise 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 Webadressen einer Website manuell ändern. Weitere Informationen findest du in diesem Hilfeartikel.

Zuordnungen von Webadressen einer Website abrufen

Wenn Sie die Zuordnungen von Webadressen für eine Website abrufen 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 gibt es drei webAddressMapping-Elemente, die auf die Website http://sites.google.com/site/myOtherTestSite verweisen.

Zuordnungen von Webadressen ändern

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

Wenn Sie eine Zuordnung hinzufügen, aktualisieren oder löschen möchten, geben Sie einen solchen Link einfach an, ändern oder entfernen Sie ihn, wenn Sie neue Websites erstellen oder die Metadaten einer Website aktualisieren. Der Parameter with-mappings=true muss im URI des Websitefeeds enthalten sein. Hinweis: Um Adresszuordnungen zu aktualisieren, müssen Sie Websiteadministrator oder, im Fall einer in G Suite gehosteten Website, Domainadministrator sein.

Mit der folgenden Anfrage wird beispielsweise die Zuordnung von http://www.mysitemapping.com zu http://www.my-new-sitemapping.com aktualisiert und http://www.mysitemapping2.com entfernt, indem der Link aus dem 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: 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.

Wenn Sie den Aktivitätsfeed abfragen möchten, senden Sie eine HTTP-GET-Anfrage an die URL des Aktivitätsfeeds:

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

Verwenden Sie in der Java-Clientbibliothek 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: Für den Zugriff auf diesen Feed müssen Sie Mitbearbeiter oder Inhaber der Website sein. Ihr Client muss sich mit einem AuthSub-, OAuth- oder ClientLogin-Token authentifizieren. Weitere Informationen finden Sie unter Authentifizierung beim Google Sites-Dienst.

Nach oben

Überarbeitungsfeed

Wenn Sie den Überarbeitungsverlauf für einen beliebigen Inhaltseintrag abrufen möchten, senden Sie eine HTTP-GET-Anfrage an den Überarbeitungslink des Eintrags:

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

In diesem Beispiel wird der Content-Feed abgefragt und dann der Revisions-Feed 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:Für den Zugriff auf diesen Feed müssen Sie Mitbearbeiter oder Inhaber der Website sein. Ihr Client muss sich mit einem AuthSub-, OAuth- oder ClientLogin-Token authentifizieren. Weitere Informationen finden Sie unter Authentifizierung beim Google Sites-Dienst.

Nach oben

Inhaltsfeed

Inhaltsfeed abrufen

Im Content-Feed werden die neuesten Inhalte einer Website aufgeführt. Sie können darauf zugreifen, indem Sie eine HTTP-GET-Anfrage an die URL des Content-Feeds senden:

https://sites.google.com/feeds/content/site/siteName
Feed parameterBeschreibung
site„site“ oder die Domain Ihrer in der G Suite gehosteten Domain (z.B. example.com).
siteNameDer Webspace-Name Ihrer Website. Sie finden ihn in der URL der Website (z. B. mySite).

Beispiel für das Abrufen des Inhaltsfeeds:

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 in contentFeed steht für eine andere Seite oder ein anderes Element auf der Website des Nutzers. Das ContentFeed-Element enthält verschiedene Arten von Objekten, die alle von BaseContentEntry abgeleitet sind: ListItemEntry, ListPageEntry, AttachmentEntry, WebAttachmentEntry, FileCabinetPageEntry, AnnouncementsPageEntry, AnnouncementEntry, WebPageEntry, CommentEntry.

Hier sehen Sie ein Beispiel für die Auflistung der verschiedenen Arten von Einträgen in einem ContentFeed. Jeder Eintragstyp enthält unterschiedliche Eigenschaften, aber nicht alle werden hier aufgeführt.

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 je nach Freigabeberechtigungen der Website möglicherweise eine Authentifizierung erforderlich. 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 Google Sites-Dienst.

Beispiele für Content-Feed-Abfragen

Sie können den Content-Feed mit einigen Standard-Abfrageparametern der Google Data API und den spezifischen Parametern der klassischen Sites API durchsuchen. 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() unter Inhaltsfeed abrufen verwendet.

Bestimmte Arten von Einträgen abrufen

Wenn Sie nur einen bestimmten Eintragstyp abrufen möchten, verwenden Sie den Parameter kind. Dieses Beispiel gibt nur attachment-Einträge zurück:

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 nach Pfad abrufen

Wenn Sie den relativen Pfad einer Seite in 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 Content-Eintrags-ID einer Seite kennen (z.B. „1234567890“ im Beispiel unten), können Sie mit dem Parameter parent alle untergeordneten Einträge abrufen (sofern 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 Client festlegen.
client.site = "siteName";

Neue Inhalte (Webseiten, Listenseiten, Ablageseiten, Ankündigungsseiten usw.) können durch Senden eines HTTP-POST an den Content-Feed erstellt werden:

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 ein neuer webpage auf der obersten Ebene der Website erstellt, der XHTML für den Seiteninhalt enthält und den Überschriftentitel auf „New WebPage Title“ (Neuer Webseitentitel) festlegt:

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

Standardmäßig würde das vorherige Beispiel unter der URL http://sites.google.com/site/siteName/new-webpage-title erstellt und die Seitenüberschrift „New Webpage Title“ (Neuer Webseitentitel) verwendet. Das bedeutet, dass <atom:title> für die URL auf new-webpage-title normalisiert wird. Wenn Sie den URL-Pfad einer Seite anpassen möchten, können Sie das <sites:pageName>-Element festlegen.

In diesem Beispiel wird eine neue Seite filecabinet mit der Überschrift „File Storage“ (Dateispeicher) erstellt. Die Seite wird jedoch unter der URL http://sites.google.com/site/siteName/files (anstatt http://sites.google.com/site/siteName/file-storage) erstellt, da das Element <sites:pageName> angegeben ist.

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, -, _ entsprechen.
  2. <atom:title> darf nicht null sein, wenn „pageName“ nicht vorhanden ist. Bei der Normalisierung werden Leerzeichen auf „-“ reduziert und zusammengefasst sowie Zeichen entfernt, die nicht mit a-z, A-Z, 0-9, -, _ übereinstimmen.

Unterseiten erstellen

Wenn Sie untergeordnete Seiten für eine übergeordnete Seite erstellen möchten, müssen Sie den übergeordneten Link im Eintrag festlegen. Das href-Attribut 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 ein neues announcement unter der ersten Ankündigungsseite im Contentfeed des Nutzers erstellt. Der Titel der Ankündigung ist auf „Party!!“ und der Inhalt auf „Bei mir, dieses Wochenende“ festgelegt.

Seitenvorlagen

Seitenvorlagen erstellen

Das Erstellen einer Seitenvorlage funktioniert genauso wie das Erstellen neuer Elemente/Seiten und Erstellen von Unterseiten. Der Unterschied besteht darin, dass das category mit dem Begriff und dem Label auf „http://schemas.google.com/g/2005#template“ bzw. „template“ festgelegt 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 instanziieren, indem Sie ein <link> mit rel='http://schemas.google.com/sites/2008#template' einfügen, das 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: Auch wenn in einer Vorlage ein <category> definiert ist, muss er in Ihrem Eintrag enthalten sein. Wenn Sie ein <content>-Element einfügen, wird es vom Server abgelehnt.

Dateien hochladen

Wie in Google Sites unterstützt die API das Hochladen von Anhängen auf eine Dateiablageseite oder eine übergeordnete Seite.

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

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 hochgeladen, das 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 einem FileCabinetPageEntry hochladen möchten, fügen Sie eine Kategorie mit dem Attribut „term“ ein, das 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 Grunde sind es Links zu anderen Dateien im Web, die Sie Ihren Dateischrankeinträgen hinzufügen können. Diese Funktion entspricht der Uploadmethode „Datei über URL hinzufügen“ in der Google Sites-Benutzeroberfläche.

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

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

Mit POST wird im Dateischrank des Nutzers ein Link zum Bild unter „http://www.google.com/images/logo.gif“ erstellt.

Nach oben


Inhalte aktualisieren

Metadaten und/oder HTML-Inhalte einer Seite aktualisieren

Die Metadaten (Titel, pageName usw.) und der Seiteninhalt eines beliebigen BaseContentEntry-Typs können mit der update()-Methode 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 die Aktualisierung 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!");

Inhalte der Anhangsdatei aktualisieren

Bei AttachmentEntry können Sie den Inhalt auch aktualisieren, indem Sie MediaSource des Eintrags festlegen und dann die Methode updateMedia(boolean) 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 die aktualisierten Inhalte.

Anhangsmetadaten und -inhalte aktualisieren

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

In diesem Beispiel wird der Titel des Anhangs in „Neuer Titel“ geändert, die Beschreibung wird aktualisiert und der Dateiinhalte werden 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 aus einer Google-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 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 einem HTTP-Code 200 OK.

Nach oben


Anhänge herunterladen

Wenn Sie eine AttachmentEntry herunterladen möchten, senden Sie eine HTTP-GET-Anfrage an den Link „content src“ 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 stellt eine Zugriffsrolle einer bestimmten Einheit dar, entweder eines Nutzers, einer Nutzergruppe, einer Domain oder des Standardzugriffs (einer öffentlichen Website). Einträge werden nur für Elemente mit explizitem Zugriff angezeigt. Für jede E-Mail-Adresse im Bereich „Personen mit Zugriff“ auf dem Freigabebildschirm der Google Sites-Benutzeroberfläche wird ein Eintrag angezeigt. Domainadministratoren werden daher nicht angezeigt, auch wenn sie impliziten Zugriff auf eine Website haben.

Rollen

Das Rollenelement stellt eine Zugriffsebene dar, die eine Entität haben kann. Das Element gAcl:role kann vier Werte haben:

  • reader: Ein Betrachter (entspricht dem schreibgeschützten Zugriff).
  • Autor: Ein Mitbearbeiter (entspricht Lese-/Schreibzugriff).
  • Inhaber: In der Regel der Websiteadministrator (entspricht Lese-/Schreibzugriff).

Bereiche

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

  • user: ein E-Mail-Adresswert, z. B. „user@gmail.com“.
  • group: Eine Google Groups-E-Mail-Adresse, z. B. „group@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">). Dieser Bereich steuert den Zugriff, den jeder Nutzer standardmäßig auf eine öffentliche Website hat.

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

ACL-Feed abrufen

Mit den Klassen AclFeed und AclEntry können die Freigabeberechtigungen einer Website gesteuert werden. 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 jedes 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 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-Website über die API freigeben möchten, muss Ihr Client ein neues AclEntry erstellen und POST an den Server senden.

Hier ein Beispiel, in dem „user@example.com“ 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);
}

Mögliche Werte für AclScope und AclRoles finden Sie im Abschnitt ACL-Feed – Übersicht.

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

Für eine gesamte Domain freigeben:

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, auf der die Website gehostet wird. Beispiel: Die Website http://sites.google.com/a/domain1.com/siteA kann nur mit domain1.com, nicht mit domain2.com geteilt werden. Bei Websites, die nicht auf 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 die betreffende AclEntry ab, ändern Sie die Berechtigung nach Bedarf und rufen Sie dann die update()-Methode der 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 „user@example.com“ als writer (Mitbearbeiter) aktualisiert 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

Um eine Freigabeberechtigung zu entfernen, 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

Spezielle Themen

Feed oder Eintrag noch einmal abrufen

Wenn Sie einen Feed oder Eintrag abrufen möchten, den Sie bereits zuvor abgerufen haben, können Sie die Effizienz verbessern, indem Sie dem Server mitteilen, dass er die Liste oder den Eintrag nur senden soll, wenn er sich seit dem letzten Abruf geändert hat.

Für diese Art des bedingten Abrufs bieten sowohl die Methoden getFeed() als auch getEntry() 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 das ETag eines Eintrags zugreifen.

In diesem Beispiel wird ein bedingter Abruf für einen Inhaltseintrag auf einer Webseite 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 der angeforderte Artikel dasselbe ETag wie das von Ihnen angegebene ETag hat. Wenn die ETags übereinstimmen, hat sich das Element nicht geändert und der Server gibt entweder eine HTTP 304-Antwort zurück oder es wird eine NotModifiedException-Ausnahme ausgelöst.

Wenn die ETags nicht übereinstimmen, wurde das Element seit dem letzten Aufruf 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