Wichtig:Dieses Dokument wurde vor 2012 verfasst. Die in diesem Dokument beschriebenen Authentifizierungsoptionen (OAuth 1.0, AuthSub und ClientLogin) wurden am 20. April 2012 offiziell eingestellt und sind nicht mehr verfügbar. Wir empfehlen Ihnen, so schnell wie möglich zu OAuth 2.0 zu migrieren.
Mit der Google Sites Data API können Client-Anwendungen auf Inhalte innerhalb einer Google Sites-Website zugreifen, diese veröffentlichen und ändern. Ihre Client-Anwendung kann auch eine Liste der letzten Aktivitäten anfordern, den Überarbeitungsverlauf abrufen und Anhänge herunterladen.
Neben Informationen zu den Funktionen der Sites Data API finden Sie in diesem Leitfaden auch Beispiele für die Interaktion mit der API mithilfe der Java-Clientbibliothek. Informationen zum Einrichten der Clientbibliothek finden Sie unter Erste Schritte mit der Google Data-Java-Clientbibliothek. Weitere Informationen zum zugrunde liegenden Protokoll, das von der Java-Clientbibliothek für die Interaktion mit der klassischen Sites API verwendet wird, finden Sie im Protokollleitfaden.
Zielgruppe
Dieses Dokument richtet sich an Entwickler, die mithilfe der Google Data-Java-Clientbibliothek Clientanwendungen erstellen möchten, die mit Google Sites interagieren.
Erste Schritte
In Google Sites werden Google-Konten oder G Suite-Konten zur Authentifizierung verwendet. Wenn Sie bereits ein Konto haben, sind Sie startklar. Andernfalls können Sie ein neues Konto erstellen.
Bibliothek installieren
Informationen zum Einrichten und Installieren der Clientbibliothek finden Sie unter Erste Schritte mit der Google Data-Java-Clientbibliothek. Wenn Sie Eclipse verwenden, wird in diesem Artikel auch erläutert, wie Sie Ihr Projekt mit dem Eclipse-Plug-in von Google Data APIs einrichten. Dafür benötigen Sie Folgendes:
- Installieren Sie Java 1.5 oder höher.
- Laden Sie die Clientbibliothek herunter (aktuelle Version von
gdata-src.java.zip
) - Liste der Abhängigkeiten herunterladen
- Laden Sie die Beispielanwendungen herunter (die neueste Version von
gdata-samples.java.zip
).
Nach der Installation der JAR-Datei müssen Sie Folgendes in Ihr Projekt aufnehmen:
java/lib/gdata-sites-2.0.jar
– Version 2.0 hier ist für Version 1.4 der klassischen Google Sites API bestimmt.java/lib/gdata-core-1.0.jar
java/lib/gdata-client-1.0.jar
java/lib/gdata-spreadsheet-3.0.jar
(wenn Sie mit Listenseiten / Listenelementen arbeiten)
Achten Sie auch darauf, die JAR-Dateien für Abhängigkeiten (gdata-media-1.0.jar
, mail.jar
und google-collect....jar
) anzugeben.
Beispielanwendung ausführen
Eine voll funktionsfähige Beispielanwendung befindet sich im Unterverzeichnis /java/sample/sites
des Downloads von gdata-samples.java.zip
.
Die Quelle ist auch unter /trunk/java/sample/sites/ im SVN-Repository verfügbar, auf das über den Tab „Quelle“ zugegriffen werden kann. Mit SitesDemo.java
kann der Nutzer eine Reihe von Vorgängen ausführen, die zeigen, wie die klassische Google Sites API verwendet wird.
Hinweis: Sie müssen java/sample/util/lib/sample-util.jar
angeben, um das Beispiel auszuführen.
Eigenes Projekt starten
Tipp: Informationen zur schnellen Einrichtung mit dem Eclipse-Plug-in finden Sie im Artikel Verwendung von Eclipse mit Google Data APIs.
Je nach den Anforderungen Ihrer Anwendung sind mehrere Importe erforderlich. Wir empfehlen, mit den folgenden Importen zu beginnen:
import com.google.gdata.client.*; import com.google.gdata.client.sites.*; import com.google.gdata.data.*; import com.google.gdata.data.acl.*; import com.google.gdata.data.media.*; import com.google.gdata.data.sites.*; import com.google.gdata.data.spreadsheet.*; // If working with listpages / listitems import com.google.gdata.util.*;
Als Nächstes müssen Sie auch ein SitesService
-Objekt einrichten, das eine Clientverbindung zur klassischen Google Sites API darstellt:
SitesService client = new SitesService("yourCo-yourAppName-v1");
Das Argument applicationName
muss das Format company-applicationname-version
haben. Dieser Parameter wird für Logging-Zwecke verwendet.
Hinweis: Im weiteren Verlauf dieses Leitfadens wird davon ausgegangen, dass Sie eine SitesService
in der Variablen client
erstellt haben.
Bei der klassischen Google Sites API authentifizieren
Die Java-Clientbibliothek kann sowohl für öffentliche als auch für private Feeds verwendet werden. Die Sites Data API bietet Zugriff auf private und öffentliche Feeds, abhängig von den Sites-Berechtigungen und dem Vorgang, den Sie ausführen möchten. Sie können beispielsweise den Inhaltsfeed einer öffentlichen Website lesen, aber keine Aktualisierungen vornehmen. Dafür ist ein authentifizierter Client erforderlich. Dies kann über die ClientLogin-Authentifizierung mit Nutzername/Passwort, AuthSub oder OAuth erfolgen.
Weitere Informationen zu AuthSub, OAuth und ClientLogin finden Sie in der Authentifizierungsübersicht der Google Data APIs.
Tipp: Die API unterstützt SSL (HTTPS). Wenn Sie AuthSub/OAuth verwenden, müssen Sie den Bereich https://sites.google.com/feeds/
angeben, um Feeds über SSL anzufordern. Beachten Sie außerdem, dass bei G Suite-Domains die Einstellung "SSL erforderlich" im Administrator-Steuerfeld von der API berücksichtigt wird. Durch Aufrufen von client.useSsl();
können Sie erzwingen, dass alle API-Anfragen über HTTPS erfolgen.
AuthSub für Webanwendungen
Die AuthSub-Authentifizierung für Webanwendungen sollte von Clientanwendungen verwendet werden, die ihre Nutzer für Google-Konten authentifizieren müssen. Der Operator benötigt keinen Zugriff auf den Nutzernamen und das Passwort des Google Sites-Nutzers – nur ein AuthSub-Token ist erforderlich.
Anleitung zum Einbinden von AuthSub in Ihre Webanwendung ansehen
Einmaltoken anfordern
Wenn der Nutzer Ihre Anwendung zum ersten Mal aufruft, muss er sich authentifizieren. Normalerweise drucken Entwickler etwas Text und einen Link aus, über den der Nutzer zur AuthSub-Genehmigungsseite gelangt, um ihn 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 von 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 Abfrageparametern entsprechen, die vom AuthSubRequest-Handler verwendet werden:
- Die nächste URL: URL, zu der Google den Nutzer weiterleitet, nachdem sich der Nutzer in seinem Konto angemeldet und Zugriff gewährt hat; im obigen Beispiel
http://www.example.com/welcome.jsp
. - scope: im obigen Beispiel
https://sites.google.com/feeds/
. - ein boolescher Wert, der angibt, ob das Token im Registrierungsmodus verwendet wird oder nicht;
false
im obigen Beispiel - einen zweiten booleschen Wert, der angibt, ob das Token später gegen ein Sitzungstoken ausgetauscht wird oder nicht;
true
im obigen Beispiel.
Upgrade auf ein Sitzungstoken ausführen
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-Apps oder installierte/mobile Anwendungen
OAuth kann als Alternative zu AuthSub verwendet werden und ist für Webanwendungen vorgesehen. OAuth ähnelt der Verwendung des sicheren und registrierten Modus von AuthSub insofern, als alle Datenanfragen digital signiert sein müssen und Sie Ihre Domain registrieren müssen.
Anleitung zum Integrieren von OAuth in die installierte Anwendung
Anfragetoken abrufen
Weitere Informationen finden Sie unter OAuth mit den Google Data API-Clientbibliotheken verwenden.
Anfragetoken autorisieren
Weitere Informationen finden Sie unter OAuth mit den Google Data API-Clientbibliotheken verwenden.
Upgrade auf ein Zugriffstoken durchführen
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. Bei der ersten Ausführung wird der Nutzer von der Anwendung zur Eingabe seines Nutzernamens und Passworts aufgefordert. Bei nachfolgenden Anfragen wird auf ein Authentifizierungstoken verwiesen.
Anleitung zum Einbinden von ClientLogin in die installierte Anwendung
Um ClientLogin zu verwenden, rufen Sie die Methode setUserCredentials()
des Objekts SitesService
auf, die von GoogleService
übernommen wird. Geben Sie die E-Mail-Adresse und das Passwort des Nutzers an, in dessen Namen Ihr Client Anfragen sendet. 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 zur späteren Verwendung abzurufen. Der Nutzer muss nicht bei jeder Ausführung Ihrer Anwendung zur Eingabe seines Passworts aufgefordert werden. Weitere Informationen finden Sie unter Authentifizierungstoken zurückrufen.
Weitere Informationen zur Verwendung von ClientLogin in Ihren Java-Anwendungen finden Sie unter ClientLogin mit den Google Data API-Clientbibliotheken verwenden.
Website-Feed
Im Website-Feed können die Google Sites-Websites aufgelistet werden, die einem Nutzer gehören oder für die er eine Anzeigeberechtigung hat. Es kann auch verwendet werden, um den Namen einer vorhandenen Website zu ändern. Bei G Suite-Domains kann damit auch eine gesamte Website erstellt und/oder kopiert werden.
Websites auflisten
Senden Sie zum Abfragen des Website-Feeds eine HTTP-GET
-Anfrage an die Website-Feed-URL:
https://sites.google.com/feeds/site/site/
Im Java-Client können Sie die Klassen SiteFeed
und SiteEntry
verwenden, um mit dem Websitefeed zu arbeiten:
public String getSiteFeedUrl() { String domain = "site"; // OR if the Site is hosted on G Suite, your domain (e.g. example.com) return "https://sites.google.com/feeds/site/" + domain + "/"; } public void getSiteFeed() throws IOException, ServiceException { SiteFeed siteFeed = client.getFeed(new URL(getSiteFeedUrl()), SiteFeed.class); for (SiteEntry entry : siteFeed.getEntries()){ System.out.println("title: " + entry.getTitle().getPlainText()); System.out.println("site name: " + entry.getSiteName().getValue()); System.out.println("theme: " + entry.getTheme().getValue()); System.out.println(""); } }
Mit dem Snippet oben werden der Titel, der Name und das Design der Website gedruckt. Für den Zugriff auf zusätzliche Properties im Feed stehen andere Getter zur Verfügung.
Neue Websites erstellen
Hinweis: Diese Funktion ist nur für G Suite-Domains verfügbar.
Neue Websites können bereitgestellt werden, indem eine neue SiteEntry
erstellt und die Methode insert()
des Clients im Websitefeed aufgerufen wird.
In diesem Beispiel wird eine brandneue Website mit dem Thema „Slate“ (optional) erstellt und der Websitename (erforderlich) und eine Beschreibung (optional) angegeben:
public String getSiteFeedUrl() { String domain = "example.com"; return "https://sites.google.com/feeds/site/" + domain + "/"; } public SiteEntry createSite(String title, String summary, String theme, String tag) throws MalformedURLException, IOException, ServiceException { SiteEntry entry = new SiteEntry(); entry.setTitle(new PlainTextConstruct(title)); entry.setSummary(new PlainTextConstruct(summary)); Theme tt = new Theme(); tt.setValue(theme); entry.setTheme(tt); entry.getCategories().add(new Category(TagCategory.Scheme.TAG, tag, null)); return client.insert(new URL(getSiteFeedUrl()), entry); } SiteEntry newSiteEntry = createSite("My Site Title", "summary for site", "slate", "tag");
Mit dieser Anfrage wird eine neue Website unter der G Suite-Domain example.com
erstellt.
Die URL der Website lautet also https://sites.google.com/a/beispiel.de/titel_meiner-website.
Wenn die Website erfolgreich erstellt wurde, gibt der Server ein SiteEntry
-Objekt zurück, das mit Elementen gefüllt ist, die vom Server hinzugefügt wurden: ein Link zur Website, ein Link zum ACL-Feed der Website, der Websitename, der Titel, eine Zusammenfassung usw.
Websites kopieren
Hinweis: Diese Funktion ist nur für G Suite-Domains verfügbar.
Das Kopieren einer Website ähnelt dem Erstellen einer neuen Website. Der Unterschied besteht darin, dass Sie in Ihrem neuen SiteEntry
einen Link festlegen müssen, der den Self-Link der zu duplizierenden Website enthält.
Hier ist ein Beispiel für das Duplizieren der Website, die im Abschnitt Neue Websites erstellen erstellt wurde:
public SiteEntry copySite(String title, String summary, String sourceHref) throws MalformedURLException, IOException, ServiceException { SiteEntry entry = new SiteEntry(); entry.setTitle(new PlainTextConstruct(title)); entry.setSummary(new PlainTextConstruct(summary)); entry.addLink(SitesLink.Rel.SOURCE, Link.Type.ATOM, sourceHref); return client.insert(new URL(getSiteFeedUrl()), entry); } String sourceHref = newSiteEntry.getLink(SitesLink.Rel.SOURCE, Link.Type.ATOM).getHref(); SiteEntry myTwin = copySite("Duplicate Site", "A copy", sourceHref);
Wichtige Punkte:
- Nur Websites und Websitevorlagen, die dem authentifizierten Nutzer gehören, können kopiert werden.
- Eine Websitevorlage kann auch kopiert werden. Eine Website ist eine Vorlage, wenn die Einstellung „Diese Website als Vorlage veröffentlichen“ auf der Seite mit den Google Sites-Einstellungen aktiviert ist.
- Solange Sie als Inhaber auf der Quellwebsite aufgeführt sind, können Sie Websites aus einer anderen Domain kopieren.
Metadaten einer Website aktualisieren
Wenn Sie eine Website umbenennen, ihr Design, ihr Kategorie-Tag oder ihre Zusammenfassung ändern möchten, müssen Sie zuerst die SiteEntry
mit der betreffenden Website abrufen, eine oder mehrere Eigenschaften ändern und dann die Methode update()
des SiteEntry
aufrufen.
In diesem Beispiel wird das Design der vorherigen Website geändert und die Website umbenannt:
myTwin.setTitle(new PlainTextConstruct("better-title")); Theme theme = myTwin.getTheme(); theme.setValue('iceberg'); myTwin.setTheme(theme); myTwin.getCategories().add(new Category(TagCategory.Scheme.TAG, "newTag", null)); SiteEntry updatedSiteEntry = myTwin.update(); System.out.println(updatedSiteEntry.getTitle().getPlainText();
Zuordnungen von Webadressen
Mithilfe von Webadressen-Zuordnungen können Google Sites-Nutzer ihre eigenen Domains einer Google Sites-Website zuordnen. Beispielsweise kann http://www.mydomainsite.com
anstelle von http://sites.google.com/a/domain.com/mysite
verwendet werden. Je nachdem, wo Ihre Website gehostet wird, können Sie die Zuordnungen der Webadresse einer Website manuell ändern. Weitere Informationen findest du in diesem Hilfeartikel.
Zuordnungen der Webadresse einer Website abrufen
Wenn Sie die Zuordnungen der Webadresse für eine Website zurückgeben möchten, rufen Sie den Websiteeintrag oder ‐feed mit dem Parameter with-mappings=true
ab:
SiteQuery query = new SiteQuery(new URL("https://sites.google.com/feeds/site/siteName")); query.setWithMappings(true); SiteFeed feed = service.getFeed(query, SiteFeed.class); for (SiteEntry entry : feed.getEntries()) { System.out.println("Mappings for '" + entry.getSiteName().getValue() + "':"); for (Link link : entry.getWebAddressMappingLinks()) { System.out.println(" " + link.getHref()); } }
Vorhandene Zuordnungen werden als link
mit rel='webAddressMapping' angezeigt. Im obigen Beispiel gibt es beispielsweise drei webAddressMapping
s, die auf die Website http://sites.google.com/site/myOtherTestSite
verweisen.
Zuordnungen von Webadressen ändern
Hinweis: Bei allen GET-/POST/PUT-Vorgängen muss der Parameter with-mappings=true
angegeben werden, wenn Sie mit Webadressenzuordnungen arbeiten. Wenn der Parameter nicht vorhanden ist, werden webAddressMapping
s in Websiteeinträgen (GET) nicht zurückgegeben und beim Aktualisieren/Entfernen (PUT) von Zuordnungen aus einem Eintrag nicht berücksichtigt.
Wenn Sie eine Zuordnung hinzufügen, aktualisieren oder löschen möchten, geben Sie einfach einen solchen Link an, ändern oder entfernen Sie ihn beim Erstellen neuer Websites oder beim Aktualisieren der Metadaten einer Website. Der Parameter with-mappings=true
muss im Website-Feed-URI enthalten sein.
Hinweis: Um Adresszuordnungen zu aktualisieren, müssen Sie Websiteadministrator oder Domainadministrator (im Fall einer G Suite-gehosteten Website) sein.
In der folgenden Anfrage wird beispielsweise die http://www.mysitemapping.com
-Zuordnung zu http://www.my-new-sitemapping.com
aktualisiert und das http://www.mysitemapping2.com
entfernt, indem der Link im Eintrag weggelassen wird:
SiteEntry entry = client.getEntry(new URL("https://sites.google.com/feeds/site/site/siteName?with-mappings=true"), SiteEntry.class); // Modify mappings (remove all mappings, add some of them again, add modified mappings) entry.removeLinks(SitesLink.Rel.WEBADDRESSMAPPING, Link.Type.HTML); entry.addLink(SitesLink.Rel.WEBADDRESSMAPPING, Link.Type.HTML, "http://www.my-new-sitemapping.com"); // Update the entry with the mappings. entry.update();
Hinweis: Webadressen-Zuordnungen können auch beim Erstellen/Kopieren einer Website angegeben werden.
Aktivitätsfeed
Sie können die letzten Aktivitäten (Änderungen) einer Website abrufen, indem Sie den Aktivitätsfeed abrufen. Jeder Eintrag im Aktivitätsfeed enthält Informationen zu einer Änderung, die an der Website vorgenommen wurde.
Um den Aktivitätsfeed abzufragen, senden Sie eine HTTP-GET
an die Aktivitätsfeed-URL:
https://sites.google.com/feeds/activity/site/siteName
Verwenden Sie im Java-Client die Klasse ActivityFeed
, um ActivityEntry
-Objekte zurückzugeben:
public String buildActivityFeedUrl() { String domain = "site"; // OR if the Site is hosted on G Suite, your domain (e.g. example.com) String siteName = "mySite"; return "https://sites.google.com/feeds/activity/" + domain + "/" + siteName + "/"; } public void getActivityFeed() throws IOException, ServiceException { ActivityFeed activityFeed = client.getFeed(new URL(buildActivityFeedUrl()), ActivityFeed.class); for (BaseActivityEntry<?> entry : activityFeed.getEntries()){ System.out.println(entry.getSummary().getPlainText()); System.out.println(" revisions link: " + entry.getRevisionLink().getHref()); } }
Hinweis: Sie müssen ein Mitbearbeiter oder Inhaber der Website sein, um auf diesen Feed zugreifen zu können. Ihr Client muss sich mit einem AuthSub-, OAuth- oder ClientLogin-Token authentifizieren. Weitere Informationen finden Sie unter Beim Sites-Dienst authentifizieren.
Überarbeitungsfeed
Um den Überarbeitungsverlauf eines Inhaltseintrags abzurufen, senden Sie eine HTTP-GET
an den Überarbeitungslink des Eintrags:
https://sites.google.com/feeds/revision/site/siteName/CONTENT_ENTRY_ID
In diesem Beispiel wird der Inhaltsfeed abgefragt und dann der Überarbeitungsfeed für den ersten Inhaltseintrag abgerufen:
ContentFeed contentFeed = client.getFeed(new URL(buildContentFeedUrl()), ContentFeed.class); URL revisionFeedUrl = new URL(contentFeed.getEntries().get(0).getRevisionLink().getHref()); // use first entry public void getRevisionFeed(String revisionFeedUrl) throws IOException, ServiceException { RevisionFeed revisionFeed = client.getFeed(revisionFeedUrl, RevisionFeed.class); for (BaseContentEntry<?> entry : revisionFeed.getEntries()){ System.out.println(entry.getTitle().getPlainText()); System.out.println(" updated: " + entry.getUpdated().toUiString() + " by " + entry.getAuthors().get(0).getEmail()); System.out.println(" revision #: " + entry.getRevision().getValue()); } }
Hinweis: Um auf diesen Feed zugreifen zu können, müssen Sie ein Mitbearbeiter oder Inhaber der Website sein. Ihr Client muss sich mit einem AuthSub-, OAuth- oder ClientLogin-Token authentifizieren. Weitere Informationen finden Sie unter Beim Sites-Dienst authentifizieren.
Inhaltsfeed
Content-Feed abrufen
Der Content-Feed enthält die neuesten Inhalte einer Website. Sie können darauf zugreifen, indem Sie eine HTTP-GET
-Anfrage an die Content-Feed-URL senden:
https://sites.google.com/feeds/content/site/siteName
Feed parameter | Beschreibung |
---|---|
site | "site " oder die Domain Ihrer von G Suite gehosteten Domain (z.B. example.com ). |
siteName | Der Webspace-Name Ihrer Website, der in der URL der Website enthalten ist (z.B. mySite ). |
Beispiel für das Abrufen des Content-Feeds:
public String buildContentFeedUrl() { String domain = "site"; // OR if the Site is hosted on G Suite, your domain (e.g. example.com) String siteName = "mySite"; return "https://sites.google.com/feeds/content/" + domain + "/" + siteName + "/"; } ContentFeed contentFeed = client.getFeed(new URL(buildContentFeedUrl()), ContentFeed.class);
Das resultierende contentFeed
ist ein ContentFeed
-Objekt, das die Antwort des Servers enthält. Jeder Eintrag von contentFeed
steht für eine andere Seite oder ein anderes Element auf der Website des Nutzers. ContentFeed
enthält verschiedene Objekttypen, die alle von BaseContentEntry
übernommen wurden: ListItemEntry
, ListPageEntry
, AttachmentEntry
, WebAttachmentEntry
, FileCabinetPageEntry
, AnnouncementsPageEntry
, AnnouncementEntry
, WebPageEntry
, CommentEntry
.
Hier ist ein Beispiel für das Auflisten der verschiedenen Arten von Einträgen in einer ContentFeed
.
Jeder Eintragstyp enthält verschiedene Eigenschaften, aber nicht alle werden hier gedruckt.
public String getContentBlob(BaseContentEntry<?> entry) { return ((XhtmlTextConstruct) entry.getTextContent().getContent()).getXhtml().getBlob(); } // Extracts an entry's numeric ID. private String getEntryId(String selfLink) { return selfLink.substring(selfLink.lastIndexOf("/") + 1); } public void printContentEntries(ContentFeed contentFeed) { System.out.println("Listing all WebPageEntry:"); for (WebPageEntry entry : contentFeed.getEntries(WebPageEntry.class)) { System.out.println(" title: " + entry.getTitle().getPlainText()); System.out.println(" id: " + getEntryId(entry)); if (entry.getParentLink() != null) { System.out.println(" parent id: " + getEntryId(entry.getParentLink().getHref())); } System.out.println(" author: " + entry.getAuthors().get(0).getEmail()); System.out.println(" content: " + getContentBlob(entry)); } System.out.println("Listing all ListPageEntry:"); for (ListPageEntry entry : contentFeed.getEntries(ListPageEntry.class)) { System.out.println(" title: " + entry.getTitle().getPlainText()); System.out.println(" id: " + getEntryId(entry)); for (Column col : entry.getData().getColumns()) { System.out.print(" [" + col.getIndex() + "] " + col.getName() + "\t"); } } for (ListItemEntry entry : contentFeed.getEntries(ListItemEntry.class)) { for (Field field : entry.getFields()) { System.out.print(" [" + field.getIndex() + "] " + field.getValue() + "\t"); } System.out.println("\n"); } System.out.println("Listing all FileCabinetPageEntry:"); for (FileCabinetPageEntry entry : contentFeed.getEntries(FileCabinetPageEntry.class)) { System.out.println(" title: " + entry.getTitle().getPlainText()); System.out.println(" id: " + getEntryId(entry)); System.out.println(" content: " + getContentBlob(entry)); } System.out.println("Listing all CommentEntry:"); for (CommentEntry entry : contentFeed.getEntries(CommentEntry.class)) { System.out.println(" in-reply-to: " + entry.getInReplyTo().toString()); System.out.println(" content: " + getContentBlob(entry)); } System.out.println("Listing all AnnouncementsPageEntry:"); for (AnnouncementsPageEntry entry : contentFeed.getEntries(AnnouncementsPageEntry.class)) { System.out.println(" title: " + entry.getTitle().getPlainText()); System.out.println(" id: " + getEntryId(entry)); System.out.println(" content: " + getContentBlob(entry)); } System.out.println("Listing all AnnouncementEntry:"); for (AnnouncementEntry entry : contentFeed.getEntries(AnnouncementEntry.class)) { System.out.println(" title: " + entry.getTitle().getPlainText()); System.out.println(" id: " + getEntryId(entry)); if (entry.getParentLink() != null) { System.out.println(" parent id: " + getEntryId(entry.getParentLink().getHref())); } System.out.println(" draft?: " + entry.isDraft()); System.out.println(" content: " + getContentBlob(entry)); } System.out.println("Listing all AttachmentEntry:"); for (AttachmentEntry entry : contentFeed.getEntries(AttachmentEntry.class)) { System.out.println(" title: " + entry.getTitle().getPlainText()); System.out.println(" id: " + getEntryId(entry)); if (entry.getParentLink() != null) { System.out.println(" parent id: " + getEntryId(entry.getParentLink().getHref())); } if (entry.getSummary() != null) { System.out.println(" description: " + entry.getSummary().getPlainText()); } System.out.println(" revision: " + entry.getRevision().getValue()); MediaContent content = (MediaContent) entry.getContent(); System.out.println(" src: " + content.getUri()); System.out.println(" content type: " + content.getMimeType().getMediaType()); } System.out.println("Listing all WebAttachmentEntry:"); for (WebAttachmentEntry entry : contentFeed.getEntries(WebAttachmentEntry.class)) { System.out.println(" title: " + entry.getTitle().getPlainText()); System.out.println(" id: " + getEntryId(entry)); if (entry.getParentLink() != null) { System.out.println(" parent id: " + getEntryId(entry.getParentLink().getHref())); } if (entry.getSummary() != null) { System.out.println(" description: " + entry.getSummary().getPlainText()); } System.out.println(" src: " + ((MediaContent) entry.getContent()).getUri()); } }
Hinweis: Für diesen Feed ist möglicherweise eine Authentifizierung erforderlich, je nach den Freigabeberechtigungen der Website. Wenn die Website nicht öffentlich ist, muss sich Ihr Client mithilfe eines AuthSub-, OAuth- oder ClientLogin-Tokens authentifizieren. Weitere Informationen finden Sie unter Beim Sites-Dienst authentifizieren.
Beispiele für Content-Feed-Suchanfragen
Sie können im Inhaltsfeed mit einigen der standardmäßigen Google Data API-Suchparameter sowie mithilfe von Parametern suchen, die für die klassische Google Sites API spezifisch sind. Ausführlichere Informationen und eine vollständige Liste der unterstützten Parameter finden Sie im Referenzhandbuch.
Hinweis: In den Beispielen in diesem Abschnitt wird die Methode buildContentFeedUrl()
aus Abrufen des Inhaltsfeeds verwendet.
Bestimmte Eintragstypen abrufen
Verwenden Sie den Parameter kind
, um nur einen bestimmten Eintragstyp abzurufen. In diesem Beispiel werden nur attachment
-Einträge zurückgegeben:
ContentQuery query = new ContentQuery(new URL(buildContentFeedUrl())); query.setKind("webpage"); ContentFeed contentFeed = client.getFeed(query, ContentFeed.class); for (AttachmentEntry entry : contentFeed.getEntries(AttachmentEntry.class)) { System.out.println(entry.getTitle().getPlainText()); }
Wenn Sie mehr als einen Eintragstyp zurückgeben möchten, trennen Sie die einzelnen kind
durch ein „,“. In diesem Beispiel werden filecabinet
- und listpage
-Einträge zurückgegeben:
URL url = new URL(buildContentFeedUrl() + "?kind=filecabinet,listpage"); ContentFeed contentFeed = client.getFeed(url, ContentFeed.class); for (FileCabinetPageEntry entry : contentFeed.getEntries(FileCabinetPageEntry.class)) { System.out.println(" title: " + entry.getTitle().getPlainText()); } for (ListPageEntry entry : contentFeed.getEntries(ListPageEntry.class)) { System.out.println(" title: " + entry.getTitle().getPlainText()); }
Seite über Pfad abrufen
Wenn Sie den relativen Pfad einer Seite innerhalb der Google Sites-Website kennen, können Sie diese Seite mithilfe des path
-Parameters abrufen.
In diesem Beispiel wird die Seite unter http://sites.google.com/site/siteName/path/to/the/page
zurückgegeben:
ContentQuery query = new ContentQuery(new URL(buildContentFeedUrl())); query.setPath("/path/to/the/page"); ContentFeed contentFeed = client.getFeed(query, ContentFeed.class); for (BaseContentEntry<?> entry : contentFeed.getEntries()) { System.out.println(" title: " + entry.getTitle().getPlainText()); }
Alle Einträge unter einer übergeordneten Seite abrufen
Wenn du die Inhaltseintrags-ID einer Seite kennst (z.B. „1234567890“ im folgenden Beispiel), kannst du mit dem Parameter parent
alle untergeordneten Einträge abrufen (falls vorhanden):
ContentQuery query = new ContentQuery(new URL(buildContentFeedUrl())); query.setParent("1234567890"); ContentFeed contentFeed = client.getFeed(query, ContentFeed.class);
Weitere Parameter finden Sie im Referenzhandbuch.
Inhalte erstellen
Hinweis: Bevor Sie Inhalte für eine Website erstellen, prüfen Sie, ob Sie Ihre Website im Client festgelegt haben.client.site = "siteName";
Sie können neue Inhalte (Web-, Listen-, Ordner- oder Ankündigungsseiten) erstellen, indem Sie eine HTTP-POST
an den Content-Feed senden:
https://sites.google.com/feeds/content/site/siteName
Eine Liste der unterstützten Knotentypen finden Sie im Referenzhandbuch unter dem Parameter kind
.
Neue Elemente / Seiten erstellen
In diesem Beispiel wird eine neue webpage
unter der obersten Ebene der Website erstellt, enthält einige XHTML für den Seitentext und legt den Titel der Überschrift auf "Neuer Titel der Webseite" fest:
private void setContentBlob(BaseContentEntry<?> entry, String pageContent) { XmlBlob xml = new XmlBlob(); xml.setBlob(pageContent); entry.setContent(new XhtmlTextConstruct(xml)); } public WebPageEntry createWebPage(String title, String content) throws MalformedURLException, IOException, ServiceException { WebPageEntry entry = new WebPageEntry(); entry.setTitle(new PlainTextConstruct(title)); setContentBlob(entry, content); // Entry's HTML content return client.insert(new URL(buildContentFeedUrl()), entry); } WebPageEntry createdEntry = createWebPage("New Webpage Title", "<b>HTML content</b>"); System.out.println("Created! View at " + createdEntry.getHtmlLink().getHref());
Wenn die Anfrage erfolgreich ist, enthält createdEntry
eine Kopie des auf dem Server erstellten Eintrags.
Elemente/Seiten unter benutzerdefinierten URL-Pfaden erstellen
Das vorherige Beispiel würde standardmäßig unter der URL http://sites.google.com/site/siteName/new-webpage-title
erstellt werden und die Seitenüberschrift „Neuer Webseitentitel“ haben. Das <atom:title>
wird für die URL zu new-webpage-title
normalisiert.
Wenn du den URL-Pfad einer Seite anpassen möchtest, kannst du das <sites:pageName>
-Element festlegen.
In diesem Beispiel wird eine neue filecabinet
-Seite mit der Überschrift "File Storage" erstellt, die Seite jedoch unter der URL http://sites.google.com/site/siteName/files
(anstelle von http://sites.google.com/site/siteName/file-storage
) erstellt, indem das Element <sites:pageName>
angegeben wird.
public FileCabinetPageEntry createFileCabinetPage(String title, String content, String customPageName) throws MalformedURLException, IOException, ServiceException { FileCabinetPageEntry entry = new FileCabinetPageEntry(); entry.setTitle(new PlainTextConstruct(title)); setContentBlob(entry, content); // Entry's HTML content entry.setPageName(new PageName(customPageName)); // Upload to a custom page path return client.insert(new URL(buildContentFeedUrl()), entry); } FileCabinetPageEntry createdEntry = createFileCabinetPage("File Storage", "<b>HTML content</b>", "files"); System.out.println("Created! View at " + createdEntry.getHtmlLink().getHref());
Der Server verwendet die folgenden Prioritätsregeln, um den URL-Pfad einer Seite zu benennen:
<sites:pageName>
, falls vorhanden. Mussa-z, A-Z, 0-9, -, _
erfüllen.<atom:title>
, darf nicht null sein, wenn „pageName“ nicht vorhanden ist. Normalisierung besteht darin, Leerzeichen auf „-“ zu kürzen und zu minimieren und Zeichen zu entfernen, die nicht mita-z, A-Z, 0-9, -, _
übereinstimmen.
Unterseiten erstellen
Um untergeordnete Seiten (untergeordnete Seiten) einer übergeordneten Seite zu erstellen, müssen Sie den übergeordneten Link im Eintrag festlegen. Das Attribut href
des Links zum Self-Link des übergeordneten Knotens.
public AnnouncementEntry postAnnouncement(String title, String content, AnnouncementsPageEntry parentPage) throws MalformedURLException, IOException, ServiceException { AnnouncementEntry entry = new AnnouncementEntry(); entry.setTitle(new PlainTextConstruct(title)); setContentBlob(entry, content); // Entry's HTML content // Set the entry's parent link to create the announcement under that page. entry.addLink(SitesLink.Rel.PARENT, Link.Type.ATOM, parentPage.getSelfLink().getHref()); return client.insert(new URL(buildContentFeedUrl()), entry); } ContentFeed contentFeed = client.getFeed(new URL(buildContentFeedUrl() + "?kind=announcementspage"), ContentFeed.class); AnnouncementEntry createdEntry = postAnnouncement("Party!!", "My place, this weekend", contentFeed.getEntries().get(0)); System.out.println("New post by " + createdEntry.getAuthors().get(0).getName());
Im Beispiel oben wird eine neue announcement
unter der ersten Ankündigungsseite im Inhaltsfeed des Nutzers erstellt. Der Titel der Ankündigung wird auf „Party!!“ und der Inhalt auf „Mein Ort, dieses Wochenende“ festgelegt.
Seitenvorlagen
Seitenvorlagen erstellen
Der Vorgang zum Erstellen einer Seitenvorlage entspricht dem Erstellen neuer Elemente/Seiten und dem Erstellen von Unterseiten. Der Unterschied besteht im Hinzufügen von category
, wobei Begriff und Label jeweils auf "http://schemas.google.com/g/2005#template" bzw. "Vorlage" festgelegt sind.
In diesem Beispiel wird eine neue webpage
-Vorlage erstellt.
// The template webpage entry. WebPageEntry entry = new WebPageEntry(); // Set title and content. entry.setTitle(new PlainTextConstruct("Page template title")); XmlBlob xml = new XmlBlob(); xml.setBlob("Content for page template"); entry.setContent(new XhtmlTextConstruct(xml)); // Set the template category Category TEMPLATE_CATEGORY = new Category(TemplateCategory.Scheme.LABELS, TemplateCategory.Term.TEMPLATE, TemplateCategory.Label.TEMPLATE); entry.getCategories().add(TEMPLATE_CATEGORY); // Insert the template webpage entry. WebPageEntry createdEntry = client.insert(new URL("https://sites.google.com/feeds/content/site/siteName"), entry);
Seiten aus einer Vorlage erstellen
Ähnlich wie beim Erstellen von Seitenvorlagen können Sie eine neue Seite aus einer Vorlage instanziieren, indem Sie ein <link>
einfügen, das rel='http://schemas.google.com/sites/2008#template' auf den Self-Link einer Seitenvorlage verweist.
In diesem Beispiel wird eine neue filecabinet
-Vorlage erstellt und dann eine neue filecabinet
-Seite aus dieser Vorlage instanziiert.
URL feedUrl = new URL("https://sites.google.com/feeds/content/site/siteName"); // 1. Create file cabinet page template FileCabinetPageEntry inputTemplateEntry = new FileCabinetPageEntry(); inputTemplateEntry.setTitle(new PlainTextConstruct("File cabinet page template title")); XmlBlob xml = new XmlBlob(); xml.setBlob("Content for page template"); inputTemplateEntry.setContent(new XhtmlTextConstruct(xml)); // Set the template category Category TEMPLATE_CATEGORY = new Category(TemplateCategory.Scheme.LABELS, TemplateCategory.Term.TEMPLATE, TemplateCategory.Label.TEMPLATE); inputTemplateEntry.getCategories().add(TEMPLATE_CATEGORY); // 2. Create file cabinet page template instance FileCabinetPageEntry templateEntry = client.insert(feedUrl, inputTemplateEntry); // Specify link to the page template FileCabinetPageEntry templateInstanceEntry = new FileCabinetPageEntry(); templateInstanceEntry.setTitle(new PlainTextConstruct("File cabinet template instance")); templateInstanceEntry.addLink(new Link(SitesLink.Rel.TEMPLATE, Link.Type.ATOM, templateEntry.getSelfLink().getHref())); FileCabinetPageEntry createdFileCabinetFromTemplate = client.insert(feedUrl, templateInstanceEntry);
Hinweis: Trotz einer Vorlage, in der eine <category>
definiert wird, müssen Sie eine in Ihrem Eintrag angeben. Wenn du ein <content>
-Element einfügst, wird es vom Server abgelehnt.
Dateien werden hochgeladen
Genau wie in Google Sites unterstützt die API das Hochladen von Anhängen auf Dateiablagenseite oder übergeordnete Seite.
Wenn Sie einen Anhang für einen übergeordneten Anhang hochladen möchten, senden Sie eine HTTP-POST
-Anfrage an die Contentfeed-URL:
https://sites.google.com/feeds/content/site/siteName
Alle Anhangstypen müssen auf eine übergeordnete Seite hochgeladen werden. Daher legen Sie einen übergeordneten Link für das AttachmentEntry
- oder WebAttachmentEntry
-Objekt fest, das Sie hochladen möchten. Weitere Informationen finden Sie unter Unterseiten erstellen.
Anhänge werden hochgeladen
In diesem Beispiel wird eine PDF-Datei in das erste FileCabinetPageEntry
im Content-Feed des Nutzers hochgeladen.
Der Anhang wird mit dem Titel „Erste Schritte“ und einer (optionalen) Beschreibung „HR-Paket“ erstellt.
MimetypesFileTypeMap mediaTypes = new MimetypesFileTypeMap(); mediaTypes.addMimeTypes("application/msword doc"); mediaTypes.addMimeTypes("application/vnd.ms-excel xls"); mediaTypes.addMimeTypes("application/pdf pdf"); mediaTypes.addMimeTypes("text/richtext rtx"); // ... See a more complete list of mime types in the SitesHelper.java public AttachmentEntry uploadAttachment(File file, BasePageEntry<?> parentPage, String title, String description) throws IOException, ServiceException { AttachmentEntry newAttachment = new AttachmentEntry(); newAttachment.setMediaSource(new MediaFileSource(file, mediaTypes.getContentType(file))); newAttachment.setTitle(new PlainTextConstruct(title)); newAttachment.setSummary(new PlainTextConstruct(description)); newAttachment.addLink(SitesLink.Rel.PARENT, Link.Type.ATOM, parentPage.getSelfLink().getHref()); return client.insert(new URL(buildContentFeedUrl()), newAttachment); } ContentFeed contentFeed = client.getFeed(new URL(buildContentFeedUrl() + "?kind=filecabinet"), ContentFeed.class); FileCabinetPageEntry parentPage = contentFeed.getEntries(FileCabinetPageEntry.class).get(0); AttachmentEntry attachment = uploadAttachment( new File("/path/to/your/file.pdf"), parentPage, "Getting Started", "HR packet"); System.out.println("Uploaded!");
Wenn der Upload erfolgreich war, enthält attachment
eine Kopie des Eintrags für den erstellten Anhang.
Anhang in einen Ordner hochladen
Wenn Sie einen Anhang in einen vorhandenen Ordner in einem FileCabinetPageEntry
hochladen möchten, fügen Sie eine Kategorie hinzu, bei der das Attribut „term“ auf den Namen des Ordners festgelegt ist.
Fügen Sie beispielsweise diese Zeile in uploadAttachment()
ein:
newAttachment.getCategories().add(new Category("http://schemas.google.com/sites/2008#folder", "FolderName"));
Webanhänge
Webanhänge sind spezielle Arten von Anhängen. Im Wesentlichen handelt es sich dabei um Links zu anderen Dateien im Web, die Sie Ihren Ordnerlisten hinzufügen können. Diese Funktion ist analog zur Upload-Methode "Datei per URL hinzufügen" in der Google Sites-Benutzeroberfläche.
Hinweis: Webanhänge können nur in einer Dateiablage erstellt werden. Sie können nicht auf andere Seitentypen hochgeladen werden.
In diesem Beispiel wird unter dem ersten FileCabinetPageEntry
im Content-Feed des Nutzers ein WebAttachmentEntry
erstellt.
Für den Titel und die optionale Beschreibung sind „GoogleLogo“ bzw. „netten Farben“ festgelegt.
public WebAttachmentEntry uploadWebAttachment(String contentUrl, FileCabinetPageEntry filecabinet, String title, String description) throws MalformedURLException, IOException, ServiceException { MediaContent content = new MediaContent(); content.setUri(contentUrl); WebAttachmentEntry webAttachment = new WebAttachmentEntry(); webAttachment.setTitle(new PlainTextConstruct(title)); webAttachment.setSummary(new PlainTextConstruct(description)); webAttachment.setContent(content); webAttachment.addLink(SitesLink.Rel.PARENT, Link.Type.ATOM, filecabinet.getSelfLink().getHref()); return client.insert(new URL(buildContentFeedUrl()), webAttachment); } ContentFeed contentFeed = client.getFeed(new URL(buildContentFeedUrl() + "?kind=filecabinet"), ContentFeed.class); FileCabinetPageEntry parentPage = contentFeed.getEntries(FileCabinetPageEntry.class).get(0); WebAttachmentEntry webAttachment = uploadWebAttachment("http://www.google.com/images/logo.gif", parentPage, "Google's Logo", "nice colors"); System.out.println("Web attachment created!");
Das POST
erstellt in der Dateiablage des Nutzers einen Link, der auf das Bild unter "http://www.google.com/images/logo.gif" verweist.
Inhalte aktualisieren
Metadaten und/oder HTML-Inhalte einer Seite aktualisieren
Die Metadaten (title, pageName usw.) und der Seiteninhalt eines beliebigen BaseContentEntry
-Typs können mit der Methode update()
des Eintrags bearbeitet werden. Dadurch wird eine HTTP-PUT
-Anfrage an den edit
-Link des Eintrags gesendet.
Im Folgenden finden Sie ein Beispiel für das Aktualisieren einer ListPageEntry
mit den folgenden Änderungen:
- Der Titel wird in „Aktualisierter Titel“ geändert.
- Der HTML-Inhalt der Seite wird zu <p>Aktualisierter HTML-Inhalt</p> aktualisiert.
- Die erste Spaltenüberschrift der Liste wird in "Inhaber" geändert.
ContentFeed contentFeed = client.getFeed( new URL(buildContentFeedUrl() + "?kind=listpage"), ContentFeed.class); ListPageEntry listPage = contentFeed.getEntries(ListPageEntry.class).get(0); // Update first list page found // Update title listPage.setTitle(new PlainTextConstruct("Updated Title")); // Update HTML content XmlBlob xml = new XmlBlob(); xml.setBlob("<p>Updated HTML Content</p>"); listPage.setContent(new XhtmlTextConstruct(xml)); // Change first column's heading listPage.getData().getColumns().get(0).setName("Owner"); // listPage.setPageName(new PageName("new-page-path")); // You can also change the page's URL path ListPageEntry updatedEntry = listPage.update(); System.out.println("ListPage updated!");
Inhalt der Anhangsdatei aktualisieren
Für AttachmentEntry
können Sie den Inhalt auch aktualisieren, indem Sie die MediaSource
des Eintrags festlegen und dann die updateMedia(boolean)
-Methode des Eintrags verwenden.
In diesem Beispiel wird der Inhalt eines vorhandenen Anhangs aktualisiert:
public AttachmentEntry updateFile(AttachmentEntry entry, File newFile) throws IOException, ServiceException { // See Uploading Attachments for the definition of mediaTypes. entry.setMediaSource(new MediaFileSource(newFile, mediaTypes.getContentType(newFile))); return entry.updateMedia(false); }
Im Beispiel wird eine HTTP-PUT
-Anfrage an den edit-media
-Link des Eintrags gesendet. Die zurückgegebene AttachmentEntry
enthält den aktualisierten Inhalt.
Metadaten und Inhalte von Anhängen werden aktualisiert
Sie können die Metadaten eines Anhangs und seinen Inhalt mit der Methode updateMedia()
im selben Aufruf aktualisieren.
Sie können nur den Dateiinhalt, die Metadaten oder beides aktualisieren.
In diesem Beispiel wird der Titel des Anhangs in „Neuer Titel“ geändert, seine Beschreibung aktualisiert und der Dateiinhalt durch eine neue ZIP-Datei ersetzt.
Da die Anfrage neuen Dateiinhalt enthält, wird der updateMedia()
von AttachmentEntry
verwendet.
public AttachmentEntry updateAttachment(AttachmentEntry entry, File newFile, String newTitle, String newDescription) throws IOException, ServiceException { // See Uploading Attachments for the definition of mediaTypes. entry.setMediaSource(new MediaFileSource(newFile, mediaTypes.getContentType(newFile))); entry.setTitle(new PlainTextConstruct(newTitle)); entry.setSummary(new PlainTextConstruct(newDescription)); return entry.updateMedia(true); } ContentFeed contentFeed = client.getFeed( new URL(buildContentFeedUrl() + "?kind=attachment&max-results=1"), ContentFeed.class); AttachmentEntry attachment = contentFeed.getEntries(AttachmentEntry.class).get(0); // Update first attachment found AttachmentEntry updatedAttachment = updateAttachment(attachment, new File("/path/to/file.zip"), "New Title", "better stuff");
Inhalte löschen
Wenn Sie eine Seite oder ein Element von einer Google Sites-Website entfernen möchten, rufen Sie zuerst den Inhaltseintrag ab und rufen Sie dann delete()
des Eintrags auf.
entry.delete();
Sie können auch die delete()
-Methode der Dienstklasse verwenden, indem Sie den edit
-Link und den ETag-Wert des Eintrags übergeben:
client.delete(entry.getEditLink().getHref(), "*"); // Note: using "*" may overwrite another client's changes.
Wurde der Eintrag erfolgreich gelöscht, antwortet der Server mit der HTTP-Anfrage 200 OK
.
Anhänge herunterladen
Um einen AttachmentEntry
herunterzuladen, senden Sie eine HTTP-GET
-Anfrage an den Content-src-Link des Eintrags.
In diesem Beispiel wird die erste AttachmentEntry
im Inhaltsfeed des Nutzers in das Verzeichnis „/path/to/save/file/“ heruntergeladen:
private void downloadFile(String downloadUrl, String fullFilePath) throws IOException, ServiceException { System.out.println("Downloading file from: " + downloadUrl); MediaContent mc = new MediaContent(); mc.setUri(downloadUrl); MediaSource ms = service.getMedia(mc); InputStream inStream = null; FileOutputStream outStream = null; try { inStream = ms.getInputStream(); outStream = new FileOutputStream(fullFilePath); int c; while ((c = inStream.read()) != -1) { outStream.write(c); } } finally { if (inStream != null) { inStream.close(); } if (outStream != null) { outStream.flush(); outStream.close(); } } } public void downloadAttachment(AttachmentEntry entry, String directory) throws IOException, ServiceException { String url = ((OutOfLineContent) entry.getContent()).getUri(); downloadFile(url, directory + entry.getTitle().getPlainText()); // Use entry's title for the save filename } ContentFeed contentFeed = client.getFeed( new URL(buildContentFeedUrl() + "?kind=attachment&max-results=1"), ContentFeed.class); downloadAttachment(contentFeed.getEntries(AttachmentEntry.class).get(0), "/path/to/save/file/"); System.out.println("Downloaded.");
ACL-Feed
Übersicht über Freigabeberechtigungen (ACLs)
Jeder ACL-Eintrag im ACL-Feed steht für eine Zugriffsrolle einer bestimmten Entität, entweder eines Nutzers, einer Gruppe von Nutzern, einer Domain oder dem Standardzugriff (eine öffentliche Website). Einträge werden nur für Entitäten mit explizitem Zugriff angezeigt. Auf dem Freigabebildschirm der Google Sites-Benutzeroberfläche wird im Bereich "Personen mit Zugriff" für jede E-Mail-Adresse ein Eintrag angezeigt. Daher werden Domainadministratoren nicht angezeigt, auch wenn sie impliziten Zugriff auf eine Website haben.
Rollen
Das Rollenelement stellt eine Zugriffsebene dar, die eine Entität haben kann. Für das Element gAcl:role
gibt es vier mögliche Werte:
- reader – ein Betrachter (entspricht dem Lesezugriff).
- writer – ein Mitbearbeiter (entspricht dem Lese-/Schreibzugriff).
- owner: normalerweise der Administrator der Website (entspricht Lese-/Schreibzugriff)
Ebenen
Das Bereichselement stellt die Entität dar, die diese Zugriffsebene hat. Es gibt vier mögliche Typen des gAcl:scope
-Elements:
- Nutzer: Ein E-Mail-Adresswert, z. B. „nutzer@gmail.com“.
- Gruppe: E-Mail-Adresse einer Google Groups-Gruppe, z. B. "gruppe@domain.com".
- domain: ein G Suite-Domainname, z. B. "domain.com".
- default: Es gibt nur einen möglichen Bereich vom Typ „default“, der keinen Wert hat (z. B.
<gAcl:scope type="default">
). Mit diesem speziellen Bereich wird der Zugriff gesteuert, den jeder Nutzer standardmäßig auf einer öffentlichen Website hat.
Hinweis: Für Domains kann der Wert gAcl:role
nicht auf „Inhaber“ festgelegt sein. Sie können nur Leser oder Autoren sein.
ACL-Feed abrufen
Mit den Klassen AclFeed
und AclEntry
können Sie die Freigabeberechtigungen einer Website steuern. Sie können mit der Methode getFeed()
der Dienstklasse abgerufen werden.
Im folgenden Beispiel wird der ACL-Feed für eine bestimmte Website abgerufen und die Berechtigungen der einzelnen AclEntry
ausgegeben:
public String getAclFeedUrl(String siteName) { String domain = "site"; // OR if the Site is hosted on G Suite, your domain (e.g. example.com) return "https://sites.google.com/feeds/acl/site/" + domain + "/" + siteName + "/"; } public void getAclFeed(String siteName) throws IOException, ServiceException { AclFeed aclFeed = client.getFeed(new URL(getAclFeedUrl(siteName)), AclFeed.class); for (AclEntry entry : aclFeed.getEntries()) { System.out.println(entry.getScope().getValue() + " (" + entry.getScope().getType() + ") : " + entry.getRole().getValue()); } } getAclFeed('my-site-name');
Wenn Sie mit Einträgen im SiteFeed arbeiten, enthält jede SiteEntry
einen Link zum zugehörigen ACL-Feed.
Mit diesem Snippet wird beispielsweise der ACL-Feed eines SiteEntry
abgerufen:
String aclLink = siteEntry.getLink(SitesAclFeedLink.Rel.ACCESS_CONTROL_LIST, Link.Type.ATOM).getHref(); AclFeed aclFeed = client.getFeed(new URL(aclLink), AclFeed.class);
Website freigeben
Hinweis: Bestimmte Freigabe-ACLs sind möglicherweise nur möglich, wenn die Domain entsprechend konfiguriert ist, z.B. wenn die Freigabe außerhalb der Domain für G Suite-Domains aktiviert ist usw.
Wenn Sie eine Google Sites-Website mithilfe der API freigeben möchten, muss Ihr Client eine neue AclEntry
erstellen und mit POST
auf den Server übertragen.
In diesem Beispiel wird „nutzer@beispiel.de“ als reader
auf der Website hinzugefügt:
AclRole role = new AclRole("reader"); AclScope scope = new AclScope(AclScope.Type.USER, "user@example.com"); AclEntry aclEntry = addAclRole(role, scope, entry); public AclEntry addAclRole(AclRole role, AclScope scope, SiteEntry siteEntry) throws IOException, MalformedURLException, ServiceException { AclEntry aclEntry = new AclEntry(); aclEntry.setRole(role); aclEntry.setScope(scope); Link aclLink = siteEntry.getLink(SitesAclFeedLink.Rel.ACCESS_CONTROL_LIST, Link.Type.ATOM); return client.insert(new URL(aclLink.getHref()), aclEntry); }
Im Abschnitt Übersicht über den ACL-Feed finden Sie die möglichen Werte für AclScope
und AclRoles
.
Freigabe auf Gruppen- und Domainebene
Ähnlich wie bei der Freigabe einer Website für einen einzelnen Nutzer können Sie eine Website für eine Google-Gruppe oder G Suite-Domain freigeben.
Freigabe für eine Gruppen-E-Mail-Adresse:
AclScope scope = new AclScope(AclScope.Type.GROUP, "group_name@example.com");
Freigabe für eine gesamte Domain:
AclScope scope = new AclScope(AclScope.Type.DOMAIN, "example.com");
Die Freigabe auf Domainebene wird nur für G Suite-Domains und nur für die Domain unterstützt, in der die Website gehostet wird. Beispielsweise kann http://sites.google.com/a/domain1.com/siteA nur die gesamte Website für domain1.com freigeben, nicht für domain2.com. Websites, die nicht auf einer G Suite-Domain gehostet werden (z.B. http://sites.google.com/site/siteB), können keine Domains einladen.
Freigabeberechtigungen ändern
Wenn Sie eine vorhandene Freigabeberechtigung für eine Website freigeben möchten, rufen Sie zuerst die betreffende AclEntry
ab, ändern Sie die Berechtigung wie gewünscht und rufen Sie dann die Methode update()
der AclEntry
auf, um die ACL auf dem Server zu ändern.
In diesem Beispiel wird unser vorheriges aclEntry
-Beispiel aus dem Bereich Website freigeben geändert. Dabei wird „nutzer@beispiel.de“ als writer
(Mitbearbeiter) aktualisiert:
aclEntry.setRole(new AclRole("writer")); AclEntry updatedAclEntry = aclEntry.update(); // Could also use the client's update method // client.update(new URL(aclEntry.getEditLink().getHref()), aclEntry);
Weitere Informationen zu ETags finden Sie im Referenzhandbuch für Google Data APIs.
Freigabeberechtigungen werden entfernt
Wenn Sie eine Freigabeberechtigung entfernen möchten, rufen Sie zuerst das AclEntry
ab und dann die zugehörige delete()
-Methode:
aclEntry.delete(); // Could also use the client's delete method // client.delete(new URL(aclEntry.getEditLink().getHref()), aclEntry);
Weitere Informationen zu ETags finden Sie im Referenzhandbuch für Google Data APIs.
Spezielle Themen
Feed oder Eintrag noch einmal abrufen
Wenn Sie einen zuvor abgerufenen Feed oder Eintrag abrufen möchten, können Sie die Effizienz verbessern, indem Sie den Server anweisen, die Liste oder den Eintrag nur dann zu senden, wenn er sich seit dem letzten Abruf geändert hat.
Für diese Art von bedingtem Abruf stellen die Methoden getFeed()
und getEntry()
ein zusätzliches Argument bereit, das einen ETag-Wert oder ein DateTime
-Objekt für den If-Modified-Since
-Header akzeptiert.
Sie können über entry.getEtag()
auf das ETag eines Eintrags zugreifen.
In diesem Beispiel wird ein bedingter Abruf für einen Eintrag auf einer Inhaltswebseite durchgeführt:
String feedUrl = "https://sites.google.com/feeds/content/site/siteName/123456789"; WebPageEntry entry = client.getEntry(new URL(feedUrl), WebPageEntry.class, "\"GVQHSARDQyp7ImBq\"");
Wenn der Server diese Anfrage erhält, prüft er, ob das angeforderte Element dasselbe ETag wie das angegebene ETag hat. Wenn die ETags übereinstimmen, hat sich das Element nicht geändert und der Server gibt entweder die HTTP-Ausnahme 304 NotModifiedException
aus.
Wenn die ETags nicht übereinstimmen, wurde das Element seit Ihrer letzten Anforderung geändert und der Server gibt das Element zurück.
Weitere Informationen zu ETags finden Sie im Referenzhandbuch für Google Data APIs.