Java-Sprachleitfaden

Wichtig:Dieses Dokument wurde vor 2012 verfasst. Authentifizierungsoptionen der in diesem Dokument beschriebenen Methoden (OAuth 1.0, AuthSub und ClientLogin) wurden offiziell eingestellt seit dem 20. April 2012 und sind nicht mehr verfügbar. Wir empfehlen Ihnen, zu OAuth 2.0 möglichst bald verwenden.

Mit der Google Sites Data API können Clientanwendungen 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.

Zusätzlich zu einigen Hintergrundinformationen zu den Funktionen der Sites Data API enthält dieses Handbuch Beispiele für die Interaktion mit der API. mithilfe der Java-Clientbibliothek. Hilfe zum Einrichten der Clientbibliothek finden Sie unter Erste Schritte mit der Google Data-Java-Clientbibliothek Wenn Sie sich für Weitere Informationen zum zugrunde liegenden Protokoll, das von der Java-Clientbibliothek für die Interaktion mit der klassischen Sites API verwendet wird, finden Sie in der Protokollleitfaden.

Zielgruppe

Dieses Dokument richtet sich an Entwickler, die Client-Anwendungen schreiben möchten, die mit Google Sites interagieren. Google Data-Java-Clientbibliothek

Erste Schritte

Google Sites verwendet Google- 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 zur Einrichtung und Installation der Clientbibliothek finden Sie unter Erste Schritte mit der Google Data-Java-Clientbibliothek. Falls Sie Eclipse verwenden, wird in diesem Artikel auch die Wie Sie Ihr Projekt mit dem Eclipse-Plug-in für Google Data APIs einrichten Hierfür benötigen Sie Folgendes:

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

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 hier ist für Version 1.4 der klassischen Google Sites API vorgesehen.
  2. java/lib/gdata-core-1.0.jar
  3. java/lib/gdata-client-1.0.jar
  4. java/lib/gdata-spreadsheet-3.0.jar (bei Verwendung von Listenseiten / Listenelementen)

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

Beispielanwendung ausführen

Eine voll funktionsfähige Beispielanwendung befindet sich im Unterverzeichnis /java/sample/sites des heruntergeladenen gdata-samples.java.zip. Die Quelle ist auch unter /trunk/java/sample/sites/ verfügbar. im SVN-Repository, auf das über den Tab „Quelle“ zugegriffen werden kann. Mit dem SitesDemo.java können Nutzer verschiedene Vorgänge ausführen, um zu demonstrieren, wie die klassische Sites API verwendet wird.

Zum Ausführen des Beispiels müssen Sie java/sample/util/lib/sample-util.jar einfügen.

Eigenes Projekt starten

Tipp: Informationen zur schnellen Einrichtung mit unserem Eclipse-Plug-in finden Sie im Artikel Eclipse mit Google Data APIs verwenden.

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

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

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

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

Bei der klassischen Sites API authentifizieren

Die Java-Client-Bibliothek kann für die Arbeit mit öffentlichen oder privaten Feeds verwendet werden. Die Sites Data API bietet Zugriff auf private und öffentliche Daten -Feeds abhängig von Ihren Sites-Berechtigungen und dem Vorgang, den Sie durchführen möchten. Vielleicht können Sie den Content-Feed von eine öffentliche Website ist, aber keine Aktualisierungen daran vornehmen. Dies erfordert einen authentifizierten Client. Dies kann über Authentifizierung mit Nutzername/Passwort für ClientLogin, AuthSub oder OAuth.

Weitere Informationen zu AuthSub, OAuth und ClientLogin finden Sie in der Übersicht zur Authentifizierung der Google Data APIs.

Tipp: Die API unterstützt SSL (HTTPS). Wenn Sie AuthSub/OAuth verwenden, müssen Sie einen Bereich von https://sites.google.com/feeds/ haben, um Feeds über SSL anzufordern. Beachten Sie außerdem, dass für G Suite-Domains „SSL erforderlich“ im Administrator-Steuerfeld wird von der API berücksichtigt. Sie können festlegen, API-Anfragen über HTTPS durch Aufrufen von client.useSsl();.

AuthSub für Webanwendungen

Die AuthSub-Authentifizierung für Webanwendungen sollte von Client-Anwendungen genutzt werden, die ihre Nutzer bei Google-Konten zu authentifizieren. Der Betreiber benötigt keinen Zugriff auf den Nutzernamen und das Passwort für den Google Sites-Nutzer, sondern nur ein AuthSub-Token ist erforderlich.

Anleitung zum Einbinden von AuthSub in Ihre Webanwendung

Einmal-Token anfordern

Wenn der Nutzer Ihre Anwendung zum ersten Mal aufruft, muss er sich authentifizieren. In der Regel drucken Entwickler einen Text und einen Link, über den die Nutzer weitergeleitet werden. zur AuthSub-Genehmigungsseite, um den Nutzer zu authentifizieren und den Zugriff auf seine Dokumente anzufordern. Die Google Data-Java-Client-Bibliothek bietet eine Funktion zum generieren Sie diese 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);

Für die Methode getRequestUrl() sind mehrere Parameter erforderlich, die den Abfrageparametern des AuthSubRequest-Handlers entsprechen:

  • die nächste URL – URL, zu der Google weiterleitet Nachdem sich der Nutzer in seinem Konto angemeldet und ihm Zugriff gewährt hat http://www.example.com/welcome.jsp im obigen Beispiel
  • den scope – https://sites.google.com/feeds/ im obigen Beispiel
  • einen booleschen Wert, der angibt, ob das Token im registrierten Modus 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

Siehe AuthSub mit den Google Data API-Clientbibliotheken verwenden

Informationen zu einem Sitzungstoken abrufen

Siehe AuthSub mit den Google Data API-Clientbibliotheken verwenden

Sitzungstoken widerrufen

Siehe AuthSub mit den Google Data API-Clientbibliotheken verwenden

OAuth für Webanwendungen oder installierte/mobile Anwendungen

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

Anleitung zur Integration von OAuth in Ihrer installierten Anwendung

Anfragetoken abrufen

Siehe OAuth mit den Google Data API-Clientbibliotheken verwenden.

Anfragetoken autorisieren

Siehe OAuth mit den Google Data API-Clientbibliotheken verwenden.

Upgrade auf ein Zugriffstoken

Siehe OAuth mit den Google Data API-Clientbibliotheken verwenden.

ClientLogin für installierte/mobile Anwendungen

ClientLogin sollte von installierten oder mobilen Apps verwendet werden, die eine ihre Nutzer bei Google-Konten zu authentifizieren. Bei der ersten Ausführung fordert Ihre Anwendung den Nutzer zur Eingabe seines Nutzernamens und Passworts auf. Bei nachfolgenden Anfragen auf ein Authentifizierungstoken verwiesen wird.

Anleitung zur Integration von ClientLogin in Ihre installierte Anwendung

Um ClientLogin zu verwenden, rufen Sie den setUserCredentials() Methode des SitesService-Objekts, das von GoogleService Geben Sie die E-Mail-Adresse und das Passwort des Nutzers an. in dessen Namen Ihr Kunde 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 Ihrem für die spätere Verwendung abrufen können. 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-Client-Bibliotheken verwenden.

Nach oben

Website-Feed

Mit dem Website-Feed können die Google Sites-Websites aufgelistet werden, die einem Nutzer gehören oder für die er Leseberechtigungen hat. Außerdem kann damit der Name einer vorhandenen Site geändert werden. Für G Suite-Domains kann damit auch ein für die gesamte Website.

Websites auflisten

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

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

Im Java-Client können Sie mit den Klassen SiteFeed und SiteEntry arbeiten. mit dem Website-Feed:

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

Das Snippet oben druckt den Titel, den Namen und das Design der Website aus. Andere Getter sind verfügbar für auf zusätzliche Unterkünfte im Feed zugreifen.

Neue Websites erstellen

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

Neue Websites können bereitgestellt werden, indem Sie eine neue SiteEntry erstellen und die insert() im Website-Feed.

In diesem Beispiel wird eine ganz neue Website mit dem Thema „Slate“ erstellt. (optionale Einstellung) und bietet Name der Website (erforderlich) und Beschreibung (optional):

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 würde eine neue Website unter der G Suite-Domain example.com erstellt werden. Die URL der Website wäre also https://sites.google.com/a/beispiel.de/titel-meine-website.

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

Website kopieren

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

Das Kopieren einer Website funktioniert ähnlich wie das Erstellen einer neuen Website. Der Unterschied besteht darin, dass Sie auf Ihrer neuen SiteEntry, der den Selbstlink der zu duplizierenden Website enthält. Hier sehen Sie 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 Hinweise:

  • 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 Option „Diese Website als Vorlage veröffentlichen“ Einstellung auf der Google Sites-Einstellungsseite aktiviert ist.
  • Sie können Websites von einer anderen Domain kopieren, sofern Sie auf der Quellwebsite als Inhaber aufgeführt sind.

Metadaten einer Website aktualisieren

Wenn Sie eine Website umbenennen, das Design, das Kategorie-Tag oder die Zusammenfassung ändern möchten, müssen Sie zuerst SiteEntry mit der betreffenden Website abrufen. ändern Sie ein oder mehrere Attribute und rufen dann die Methode update() des SiteEntry auf. 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();

Webadressen-Zuordnungen

Mithilfe von Webadressen-Zuordnungen können Google Sites-Nutzer ihre eigenen Domains einer Google Sites-Website zuordnen. Beispiel: http://www.mydomainsite.com kann 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. Weitere Informationen finden Sie in diesem Hilfeartikel.

Webadressen-Zuordnungen einer Website abrufen

Um die Webadressen-Zuordnungen für eine Website zurückzugeben, rufen Sie den Websiteeintrag bzw. -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 mit rel='webAddressMapping' als links angezeigt. Im Beispiel oben Es gibt drei webAddressMappings, die auf die Website verweisen. http://sites.google.com/site/myOtherTestSite.

Webadressen-Zuordnungen ändern

Hinweis: Für alle GET/POST/PUT-Vorgänge muss der Parameter with-mappings=true angegeben werden. mit Webadressen-Zuordnungen. Fehlt der Parameter, werden webAddressMapping-Werte in Websiteeinträgen (GET) nicht zurückgegeben und nicht berücksichtigt beim Aktualisieren/Entfernen (PUT) von Zuordnungen aus einem Eintrag.

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

Mit der folgenden Anfrage wird beispielsweise die http://www.mysitemapping.com-Zuordnung zu http://www.my-new-sitemapping.com aktualisiert. und entfernt http://www.mysitemapping2.com, indem der Link aus dem Eintrag entfernt 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: Die Zuordnung von Webadressen kann auch beim Erstellen/Kopieren einer Website angegeben werden.

Nach oben

Aktivitätsfeed

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

Senden Sie zum Abfragen des Aktivitätsfeeds eine HTTP-GET-Anfrage an die Aktivitätsfeed-URL:

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

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

public String buildActivityFeedUrl() {
  String domain = "site";  // OR if the Site is hosted on G Suite, your domain (e.g. example.com)
  String siteName = "mySite";
  return "https://sites.google.com/feeds/activity/" + domain + "/" + siteName + "/";
}

public void getActivityFeed() throws IOException, ServiceException {
  ActivityFeed activityFeed = client.getFeed(new URL(buildActivityFeedUrl()), ActivityFeed.class);
  for (BaseActivityEntry<?> entry : activityFeed.getEntries()){
    System.out.println(entry.getSummary().getPlainText());
    System.out.println(" revisions link: " + entry.getRevisionLink().getHref());
  }
}

Hinweis: Damit Sie auf diesen Feed zugreifen können, müssen Sie Mitbearbeiter oder Inhaber der Website sein. Ihr Client muss sich mithilfe eines AuthSub-, OAuth- oder ClientLogin-Tokens authentifizieren. Weitere Informationen finden Sie unter Beim Google Sites-Dienst authentifizieren.

Nach oben

Überarbeitungsfeed

Wenn Sie den Überarbeitungsverlauf eines Inhaltseintrags abrufen möchten, 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 Content-Feed abgefragt und dann der Überarbeitungsfeed für den ersten Content-Eintrag abgerufen:

ContentFeed contentFeed = client.getFeed(new URL(buildContentFeedUrl()), ContentFeed.class);
URL revisionFeedUrl = new URL(contentFeed.getEntries().get(0).getRevisionLink().getHref()); // use first entry

public void getRevisionFeed(String revisionFeedUrl) throws IOException, ServiceException {
  RevisionFeed revisionFeed = client.getFeed(revisionFeedUrl, RevisionFeed.class);
  for (BaseContentEntry<?> entry : revisionFeed.getEntries()){
    System.out.println(entry.getTitle().getPlainText());
    System.out.println(" updated: " + entry.getUpdated().toUiString() + " by " +
        entry.getAuthors().get(0).getEmail());
    System.out.println(" revision #: " + entry.getRevision().getValue());
  }
}

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

Nach oben

Inhaltsfeed

Content-Feed abrufen

Der Content-Feed listet den neuesten Content einer Website auf. Sie können darauf zugreifen, indem Sie eine HTTP-GET-Anfrage an die Content-Feed-URL senden:

https://sites.google.com/feeds/content/site/siteName
Feed parameterBeschreibung
site„site“ oder die Domain Ihrer von G Suite gehosteten Domain (z.B. example.com).
siteNameDer Webspace-Name Ihrer Website in der URL der Website gefunden werden (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);

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

Hier ist ein Beispiel für die Auflistung der verschiedenen Eintragstypen in einem ContentFeed. Jeder Eintragstyp enthält verschiedene Eigenschaften, aber nicht alle werden hier angegeben.

public String getContentBlob(BaseContentEntry<?> entry) {
 return ((XhtmlTextConstruct) entry.getTextContent().getContent()).getXhtml().getBlob();
}

// Extracts an entry's numeric ID.
private String getEntryId(String selfLink) {
  return selfLink.substring(selfLink.lastIndexOf("/") + 1);
}

public void printContentEntries(ContentFeed contentFeed) {
  System.out.println("Listing all WebPageEntry:");
  for (WebPageEntry entry : contentFeed.getEntries(WebPageEntry.class)) {
    System.out.println(" title: " + entry.getTitle().getPlainText());
    System.out.println(" id: " + getEntryId(entry));
    if (entry.getParentLink() != null) {
      System.out.println(" parent id: " + getEntryId(entry.getParentLink().getHref()));
    }
    System.out.println(" author: " + entry.getAuthors().get(0).getEmail());
    System.out.println(" content: " + getContentBlob(entry));
  }

  System.out.println("Listing all ListPageEntry:");
  for (ListPageEntry entry : contentFeed.getEntries(ListPageEntry.class)) {
    System.out.println(" title: " + entry.getTitle().getPlainText());
    System.out.println(" id: " + getEntryId(entry));
    for (Column col : entry.getData().getColumns()) {
      System.out.print(" [" + col.getIndex() + "] " + col.getName() + "\t");
    }
  }

  for (ListItemEntry entry : contentFeed.getEntries(ListItemEntry.class)) {
    for (Field field : entry.getFields()) {
      System.out.print(" [" + field.getIndex() + "] " + field.getValue() + "\t");
    }
    System.out.println("\n");
  }

  System.out.println("Listing all FileCabinetPageEntry:");
  for (FileCabinetPageEntry entry : contentFeed.getEntries(FileCabinetPageEntry.class)) {
    System.out.println(" title: " + entry.getTitle().getPlainText());
    System.out.println(" id: " + getEntryId(entry));
    System.out.println(" content: " + getContentBlob(entry));
  }

  System.out.println("Listing all CommentEntry:");
  for (CommentEntry entry : contentFeed.getEntries(CommentEntry.class)) {
    System.out.println(" in-reply-to: " + entry.getInReplyTo().toString());
    System.out.println(" content: " + getContentBlob(entry));
  }

  System.out.println("Listing all AnnouncementsPageEntry:");
  for (AnnouncementsPageEntry entry : contentFeed.getEntries(AnnouncementsPageEntry.class)) {
    System.out.println(" title: " + entry.getTitle().getPlainText());
    System.out.println(" id: " + getEntryId(entry));
    System.out.println(" content: " + getContentBlob(entry));
  }

  System.out.println("Listing all AnnouncementEntry:");
  for (AnnouncementEntry entry : contentFeed.getEntries(AnnouncementEntry.class)) {
    System.out.println(" title: " + entry.getTitle().getPlainText());
    System.out.println(" id: " + getEntryId(entry));
    if (entry.getParentLink() != null) {
      System.out.println(" parent id: " + getEntryId(entry.getParentLink().getHref()));
    }
    System.out.println(" draft?: " + entry.isDraft());
    System.out.println(" content: " + getContentBlob(entry));
  }

  System.out.println("Listing all AttachmentEntry:");
  for (AttachmentEntry entry : contentFeed.getEntries(AttachmentEntry.class)) {
    System.out.println(" title: " + entry.getTitle().getPlainText());
    System.out.println(" id: " + getEntryId(entry));
    if (entry.getParentLink() != null) {
      System.out.println(" parent id: " + getEntryId(entry.getParentLink().getHref()));
    }
    if (entry.getSummary() != null) {
      System.out.println(" description: " + entry.getSummary().getPlainText());
    }
    System.out.println(" revision: " + entry.getRevision().getValue());
    MediaContent content = (MediaContent) entry.getContent();
    System.out.println(" src: " + content.getUri());
    System.out.println(" content type: " + content.getMimeType().getMediaType());
  }

  System.out.println("Listing all WebAttachmentEntry:");
  for (WebAttachmentEntry entry : contentFeed.getEntries(WebAttachmentEntry.class)) {
    System.out.println(" title: " + entry.getTitle().getPlainText());
    System.out.println(" id: " + getEntryId(entry));
    if (entry.getParentLink() != null) {
      System.out.println(" parent id: " + getEntryId(entry.getParentLink().getHref()));
    }
    if (entry.getSummary() != null) {
      System.out.println(" description: " + entry.getSummary().getPlainText());
    }
    System.out.println(" src: " + ((MediaContent) entry.getContent()).getUri());
  }
}

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

Beispiele für Suchanfragen in Content-Feeds

Sie können den Content-Feed mithilfe einiger standardmäßiger Suchparameter für die Google Data API durchsuchen. und die für die klassische Google Sites API. Ausführlichere Informationen und eine vollständige Liste der unterstützten Parameter finden Sie in der Referenzhandbuch.

Hinweis: In den Beispielen in diesem Abschnitt wird die buildContentFeedUrl()-Methode unter Content-Feed abrufen verwendet.

Bestimmte Eintragstypen abrufen

Wenn Sie nur einen bestimmten Eintragstyp abrufen möchten, verwenden Sie den Parameter kind. In diesem Beispiel werden nur attachment-Einträge zurückgegeben:

ContentQuery query = new ContentQuery(new URL(buildContentFeedUrl()));
query.setKind("webpage");
ContentFeed contentFeed = client.getFeed(query, ContentFeed.class);
for (AttachmentEntry entry : contentFeed.getEntries(AttachmentEntry.class)) {
  System.out.println(entry.getTitle().getPlainText());
}

Wenn Sie mehrere Eintragstypen zurückgeben möchten, trennen Sie die einzelnen kind durch ein „,“. Dieses Beispiel gibt filecabinet und listpage Einträge:

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 bestimmte Seite mit dem Parameter path abrufen. In diesem Beispiel wird die Seite http://sites.google.com/site/siteName/path/to/the/page:

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

Alle Einträge unter einer übergeordneten Seite abrufen

Wenn Sie die Inhaltseintrags-ID einer Seite kennen (z. B. „1234567890“ im Beispiel unten), können Sie den Parameter parent verwenden. , um alle untergeordneten Einträge abzurufen (falls vorhanden):

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

Informationen zu weiteren Parametern finden Sie im Referenzhandbuch.

Nach oben


Inhalte erstellen

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

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

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

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

Neue Elemente / Seiten erstellen

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

private void setContentBlob(BaseContentEntry<?> entry, String pageContent) {
  XmlBlob xml = new XmlBlob();
  xml.setBlob(pageContent);
  entry.setContent(new XhtmlTextConstruct(xml));
}

public WebPageEntry createWebPage(String title, String content)
    throws MalformedURLException, IOException, ServiceException {
  WebPageEntry entry = new WebPageEntry();
  entry.setTitle(new PlainTextConstruct(title));

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

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

WebPageEntry createdEntry = createWebPage("New Webpage Title", "<b>HTML content</b>");
System.out.println("Created! View at " + createdEntry.getHtmlLink().getHref());

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

Elemente/Seiten unter benutzerdefinierten URL-Pfaden erstellen

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

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

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 wendet für die Benennung des URL-Pfads einer Seite die folgenden Rangfolgeregeln an:

  1. <sites:pageName>, falls vorhanden. Muss a-z, A-Z, 0-9, -, _ erfüllen.
  2. <atom:title>, darf nicht null sein, wenn pageName nicht vorhanden ist. Normalisierung ist das Kürzen und Minimieren von Leerzeichen in „-“. und Zeichen entfernen, die nicht mit a-z, A-Z, 0-9, -, _ übereinstimmen.

Unterseiten erstellen

Um untergeordnete Seiten unter einer übergeordneten Seite zu erstellen, müssen Sie im Eintrag den übergeordneten Link festlegen. Das Attribut href des Links für den 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 erstellt in im Content-Feed des Nutzers. Der Titel der Ankündigung wurde auf „Party!!“ festgelegt. und den Inhalt zu "Mein Ort, dieses Wochenende".

Seitenvorlagen

Seitenvorlagen erstellen

Der Vorgang zum Erstellen einer Seitenvorlage entspricht dem zum Erstellen neuer Elemente/Seiten und Erstellen von Unterseiten. Der Unterschied besteht darin, dass category mit Begriff und Label auf "http://schemas.google.com/g/2005#template" gesetzt ist. und 'Vorlage'.

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. zeigend zum Self-Link einer Seitenvorlage.

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: Obwohl eine Vorlage, die ein <category> definiert, auch eine in Ihrem ist immer noch erforderlich. Wenn du ein <content>-Element einfügst, wird es vom Server abgelehnt.

Hochladen von Dateien

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

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

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

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

Anhänge werden hochgeladen

In diesem Beispiel wird eine PDF-Datei in die erste FileCabinetPageEntry im Content-Feed des Nutzers hochgeladen. Der Anhang hat den Titel „Erste Schritte“. und eine (optionale) Beschreibung: "HR-Paket".

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, geben Sie eine Kategorie mit dem Begriff „term“ an. auf den Namen des Ordners festgelegt. Fügen Sie beispielsweise diese Zeile in uploadAttachment() hinzu:

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

Webanhänge

Webanhänge sind spezielle Arten von Anhängen. Im Wesentlichen handelt es sich um Links zu anderen Dateien im Web. die Sie Ihren Ordnerlisten hinzufügen können. Diese Funktion entspricht der Funktion „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 Arten von Seiten hochgeladen werden.

In diesem Beispiel wird ein WebAttachmentEntry unter der ersten FileCabinetPageEntry im Content-Feed des Nutzers erstellt. Der Titel und die (optionale) Beschreibung sind auf „GoogleLogo“ festgelegt. und 'nice color' [schöne Farben].

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 Dateiablage des Nutzers ein Link erstellt, der auf das Bild unter "http://www.google.com/images/logo.gif" verweist.

Nach oben


Inhalte aktualisieren

Metadaten und/oder HTML-Inhalte einer Seite aktualisieren

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

Im Folgenden finden Sie ein Beispiel für die Aktualisierung eines ListPageEntry mit den folgenden Änderungen:

  • Der Titel wurde in „Aktualisierter Titel“ geändert
  • Der HTML-Inhalt der Seite wird aktualisiert zu "<p>Aktualisierte HTML-Inhalte</p>".
  • 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 von Anhängen aktualisieren

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

In diesem Beispiel wird der Inhalt eines vorhandenen Anhangs aktualisiert:

public AttachmentEntry updateFile(AttachmentEntry entry, File newFile)
    throws IOException, ServiceException {
  // See Uploading Attachments for the definition of mediaTypes.
  entry.setMediaSource(new MediaFileSource(newFile, mediaTypes.getContentType(newFile)));
  return entry.updateMedia(false);
}

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

Metadaten und Inhalte von Anhängen aktualisieren

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

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

public AttachmentEntry updateAttachment(AttachmentEntry entry, File newFile, String newTitle, String newDescription)
    throws IOException, ServiceException  {
  // See Uploading Attachments for the definition of mediaTypes.
  entry.setMediaSource(new MediaFileSource(newFile, mediaTypes.getContentType(newFile)));
  entry.setTitle(new PlainTextConstruct(newTitle));
  entry.setSummary(new PlainTextConstruct(newDescription));

  return entry.updateMedia(true);
}

ContentFeed contentFeed = client.getFeed(
    new URL(buildContentFeedUrl() + "?kind=attachment&max-results=1"), ContentFeed.class);
AttachmentEntry attachment = contentFeed.getEntries(AttachmentEntry.class).get(0); // Update first attachment found

AttachmentEntry updatedAttachment = updateAttachment(attachment, new File("/path/to/file.zip"), "New Title", "better stuff");

Nach oben


Inhalte löschen

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

entry.delete();

Sie können auch die Methode delete() 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.

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

Nach oben


Anhänge herunterladen

Senden Sie zum Herunterladen eines AttachmentEntry eine HTTP-GET-Anfrage an den Content src-Link des Eintrags.

In diesem Beispiel werden die ersten AttachmentEntry heruntergeladen, die im Contentfeed des Nutzers gefunden wurden. in das Verzeichnis "/path/to/save/file/":

private void downloadFile(String downloadUrl, String fullFilePath) throws IOException, ServiceException {
  System.out.println("Downloading file from: " + downloadUrl);

  MediaContent mc = new MediaContent();
  mc.setUri(downloadUrl);
  MediaSource ms = service.getMedia(mc);

  InputStream inStream = null;
  FileOutputStream outStream = null;

  try {
    inStream = ms.getInputStream();
    outStream = new FileOutputStream(fullFilePath);

    int c;
    while ((c = inStream.read()) != -1) {
      outStream.write(c);
    }
  } finally {
    if (inStream != null) {
      inStream.close();
    }
    if (outStream != null) {
      outStream.flush();
      outStream.close();
    }
  }
}

public void downloadAttachment(AttachmentEntry entry, String directory) throws IOException, ServiceException {
  String url = ((OutOfLineContent) entry.getContent()).getUri();
  downloadFile(url, directory + entry.getTitle().getPlainText()); // Use entry's title for the save filename
}

ContentFeed contentFeed = client.getFeed(
    new URL(buildContentFeedUrl() + "?kind=attachment&max-results=1"), ContentFeed.class);

downloadAttachment(contentFeed.getEntries(AttachmentEntry.class).get(0), "/path/to/save/file/");
System.out.println("Downloaded.");

Nach oben

ACL-Feed

Übersicht über Freigabeberechtigungen (ACLs)

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

Rollen

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

  • reader – Ein Viewer (entspricht Lesezugriff).
  • writer – ein Mitbearbeiter (entspricht Lese-/Schreibzugriff).
  • owner – in der Regel der Websiteadministrator (entspricht Lese-/Schreibzugriff)

Ebenen

Das Bereichselement stellt die Entität mit dieser Zugriffsebene dar. Es gibt vier mögliche Typen von gAcl:scope-Elementen:

  • user – Wert für eine E-Mail-Adresse, z. B. „nutzer@gmail.com“.
  • group – eine E-Mail-Adresse einer Google-Gruppe, z. B. „gruppe@domain.com“.
  • domain – ein G Suite-Domainname, z. B. „domain.com“.
  • Standard: Es gibt nur einen Bereich vom Typ „Standard“, der keinen Wert hat. (z. B. <gAcl:scope type="default">). Dieser bestimmte Bereich steuert den Zugriff, den jeder Nutzer standardmäßig hat auf einer öffentlichen Website.

Hinweis: Domains dürfen nicht den Wert gAcl:role haben. auf „owner“ festgelegt können nur Leser oder Autoren sein.

ACL-Feed abrufen

Mit den Klassen AclFeed und AclEntry kann die Freigabe einer Website gesteuert werden Berechtigungen und kann mit der Methode getFeed() der Dienstklasse abgerufen werden.

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

public String getAclFeedUrl(String siteName) {
  String domain = "site";  // OR if the Site is hosted on G Suite, your domain (e.g. example.com)
  return "https://sites.google.com/feeds/acl/site/" + domain + "/" + siteName + "/";
}

public void getAclFeed(String siteName) throws IOException, ServiceException {
  AclFeed aclFeed = client.getFeed(new URL(getAclFeedUrl(siteName)), AclFeed.class);
  for (AclEntry entry : aclFeed.getEntries()) {
    System.out.println(entry.getScope().getValue() + " (" + entry.getScope().getType() + ") : " +
                       entry.getRole().getValue());
  }
}

getAclFeed('my-site-name');

Wenn Sie mit Einträgen im SiteFeed arbeiten, enthält jeder SiteEntry einen Link zum entsprechenden ACL-Feed. Das folgende Snippet ruft beispielsweise den ACL-Feed eines SiteEntry ab:

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

Website freigeben

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

Um eine Google Sites-Website mithilfe der API freizugeben, muss Ihr Kunde eine neue AclEntry und POST an den Server senden.

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

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

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

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

Im Abschnitt ACL-Feed – Übersicht finden Sie mögliche AclScope. und AclRoles-Werte.

Freigabe auf Gruppen- und Domainebene

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

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 in einer G Suite-Domain gehostet werden (z.B. http://sites.google.com/site/siteB), können keine Domains einladen.

Freigabeberechtigungen ändern

Wenn auf einer Website eine vorhandene Freigabeberechtigung vorhanden ist, rufen Sie zuerst die betreffenden AclEntry ab und ändern Sie die Berechtigung wie gewünscht und rufen Sie dann die Methode update() des AclEntry auf, um die ACL auf dem Server zu ändern.

In diesem Beispiel wird unser vorheriges aclEntry-Beispiel aus dem Abschnitt Website freigeben geändert. durch Aktualisieren von „nutzer@beispiel.de“ writer (Mitbearbeiter): 

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 über 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-Objekt ab und rufen Sie dann seine delete()-Methode auf:

aclEntry.delete();

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

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

Nach oben

Besondere Themen

Feed oder Eintrag noch einmal abrufen

Wenn Sie bereits abgerufene Feeds oder Einträge abrufen möchten, verbessern Sie die Effizienz, indem Sie angeben, um die Liste oder den Eintrag nur dann zu senden, wenn sie sich seit dem letzten Abruf geändert hat.

Für diese Art des bedingten Abrufs bieten die Methoden getFeed() und 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 eines Inhaltswebseiteneintrags 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, überprüft er, ob das angeforderte Element dasselbe ETag wie das angegebene ETag. Stimmen die ETags überein, hat sich das Element nicht geändert und der Server gibt entweder eine HTTP 304-Ausnahme NotModifiedException wird ausgelöst.

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

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

Nach oben