Przewodnik po języku Java

Ważne: ten dokument został napisany przed 2012 r. Opcje uwierzytelniania opisane w tym dokumencie (OAuth 1.0, AuthSub i ClientLogin) zostały oficjalnie wycofane 20 kwietnia 2012 r. i nie są już dostępne. Zachęcamy do jak najszybszego przejścia na OAuth 2.0.

Interfejs Google Sites Data API umożliwia aplikacjom klienckim uzyskiwanie dostępu do treści w Witrynie Google, publikowanie ich i modyfikowanie. Aplikacja kliencka może też wysyłać prośby o listę ostatniej aktywności, pobierać historię zmian i pobierać załączniki.

Ten przewodnik zawiera nie tylko podstawowe informacje o możliwościach interfejsu Sites Data API, ale też przykłady interakcji z nim za pomocą biblioteki klienta Java. Aby uzyskać pomoc w konfigurowaniu biblioteki klienta, przeczytaj artykuł Rozpoczynanie pracy z biblioteką klienta Google Data Java. Jeśli chcesz dowiedzieć się więcej o protokole bazowym używanym przez bibliotekę klienta Java do interakcji z klasyczną wersją Witryn API, zapoznaj się z przewodnikiem po protokole.

Odbiorcy

Ten dokument jest przeznaczony dla deweloperów, którzy chcą tworzyć aplikacje klienckie wchodzące w interakcję z Witrynami Google za pomocą biblioteki klienta Google Data Java.

Pierwsze kroki

Witryny Google używają kont Google lub kont G Suite do uwierzytelniania. Jeśli masz już konto, nie musisz nic więcej robić. W przeciwnym razie możesz utworzyć nowe konto.

Instalowanie biblioteki

Aby uzyskać pomoc w konfigurowaniu i instalowaniu biblioteki klienta, zapoznaj się z artykułem Wprowadzenie do biblioteki klienta Google Data w języku Java. Jeśli używasz Eclipse, w tym artykule znajdziesz też informacje o tym, jak skonfigurować projekt za pomocą wtyczki Eclipse do interfejsów API danych Google. Oto co musisz zrobić, aby rozpocząć:

1. Zainstaluj Javę w wersji 1.5 lub nowszej.
2. Pobierz bibliotekę klienta (najnowszą wersję gdata-src.java.zip).
3. Pobierz listę zależności
4. Pobierz przykładowe aplikacje (najnowszą wersję gdata-samples.java.zip).

Po zainstalowaniu plików JAR musisz uwzględnić w projekcie te elementy:

1. java/lib/gdata-sites-2.0.jar – wersja 2.0 jest przeznaczona dla wersji 1.4 klasycznego interfejsu Sites API.
2. java/lib/gdata-core-1.0.jar
3. java/lib/gdata-client-1.0.jar
4. java/lib/gdata-spreadsheet-3.0.jar (jeśli pracujesz ze stronami z listami lub elementami listy)

Pamiętaj też, aby uwzględnić pliki JAR zależności (gdata-media-1.0.jar, mail.jar i google-collect....jar).

Uruchamianie przykładowej aplikacji

Pełna działająca przykładowa aplikacja znajduje się w podkatalogu /java/sample/sites pobranego pakietu gdata-samples.java.zip. Źródło jest też dostępne w repozytorium SVN na karcie Źródło w folderze /trunk/java/sample/sites/. SitesDemo.java umożliwia użytkownikowi wykonanie szeregu operacji, które pokazują, jak korzystać z interfejsu API klasycznej wersji Witryn.

Pamiętaj, że aby uruchomić przykład, musisz dodać java/sample/util/lib/sample-util.jar.

Rozpoczynanie własnego projektu

Wskazówka: aby szybko skonfigurować wtyczkę Eclipse, przeczytaj artykuł Korzystanie z Eclipse z interfejsami Google Data API.

W zależności od potrzeb aplikacji konieczne będzie kilka importów. Zalecamy rozpoczęcie od tych importów:

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

Następnie musisz też skonfigurować obiekt SitesService, który reprezentuje połączenie klienta z interfejsem Sites API klasycznej wersji Witryn:

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

Argument applicationName powinien mieć format: company-applicationname-version. Ten parametr jest używany do celów rejestrowania.

Uwaga: w dalszej części tego przewodnika przyjęliśmy założenie, że w zmiennej client utworzono SitesService.

Uwierzytelnianie w interfejsie Sites API klasycznej wersji Witryn

Biblioteki klienta Java można używać do pracy z publicznymi i prywatnymi plikami danych. Interfejs Sites Data API zapewnia dostęp do prywatnych i publicznych kanałów danych w zależności od uprawnień w Witrynach Google i operacji, którą chcesz wykonać. Możesz na przykład odczytać źródło treści publicznej Witryny, ale nie możesz go aktualizować – do tego potrzebny jest uwierzytelniony klient. Można to zrobić za pomocą uwierzytelniania ClientLogin (nazwa użytkownika i hasło), AuthSub lub OAuth.

Więcej informacji o AuthSub, OAuth i ClientLogin znajdziesz w przeglądzie uwierzytelniania w interfejsach API danych Google.

Wskazówka: interfejs API obsługuje protokół SSL (HTTPS). Jeśli używasz AuthSub/OAuth, aby wysyłać żądania dotyczące plików danych przez SSL, musisz określić zakres https://sites.google.com/feeds/. Pamiętaj też, że w przypadku domen G Suite interfejs API uwzględnia ustawienie „Wymagaj SSL” w panelu administracyjnym. Możesz wymusić, aby wszystkie żądania interfejsu API były wysyłane przez HTTPS, wywołując client.useSsl();.

AuthSub w przypadku aplikacji internetowych

Uwierzytelnianie AuthSub w przypadku aplikacji internetowych powinno być używane przez aplikacje klienckie, które muszą uwierzytelniać użytkowników na kontach Google. Operator nie potrzebuje dostępu do nazwy użytkownika i hasła użytkownika Witryn Google – wystarczy token AuthSub.

import com.google.gdata.client.*;

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

import com.google.gdata.client.*;

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

OAuth w przypadku aplikacji internetowych lub zainstalowanych/mobilnych

OAuth może być używany jako alternatywa dla AuthSub i jest przeznaczony dla aplikacji internetowych. OAuth jest podobny do korzystania z bezpiecznego i zarejestrowanego trybu AuthSub, ponieważ wszystkie żądania danych muszą być podpisane cyfrowo, a domena musi być zarejestrowana.

ClientLogin w przypadku zainstalowanych aplikacji i aplikacji mobilnych

ClientLogin powinny używać zainstalowane aplikacje lub aplikacje mobilne, które muszą uwierzytelniać użytkowników na kontach Google. Przy pierwszym uruchomieniu aplikacja prosi użytkownika o podanie nazwy użytkownika i hasła. W kolejnych żądaniach odwołuje się do tokena uwierzytelniania.

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

Powrót do góry

Plik danych witryny

Plik danych o witrynach może służyć do wyświetlania listy witryn Google, których użytkownik jest właścicielem lub do których ma uprawnienia do wyświetlania. Można go też użyć do zmiany nazwy istniejącej witryny. W przypadku domen G Suite można go też używać do tworzenia lub kopiowania całej witryny.

Witryny z informacjami o produktach

Aby wysłać zapytanie do pliku danych o witrynie, wyślij żądanie HTTP GET na adres URL pliku danych o witrynie:

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

W kliencie Java możesz używać klas SiteFeed i SiteEntry do pracy z plikiem danych o witrynie:

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

Powyższy fragment kodu wyświetla tytuł witryny, jej nazwę i motyw. Dostępne są też inne metody pobierania, które umożliwiają dostęp do dodatkowych właściwości w pliku danych.

Tworzenie nowych witryn

Uwaga: ta funkcja jest dostępna tylko w domenach G Suite.

Nowe witryny można udostępniać, tworząc nowy SiteEntry i wywołując metodę insert() klienta w pliku danych o witrynie.

W tym przykładzie tworzymy nową witrynę z motywem „slate” (ustawienie opcjonalne) oraz podajemy nazwę witryny (wymagane) i opis (opcjonalny):

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

Powyższa prośba spowoduje utworzenie nowej witryny w domenie G Suite example.com. Adres URL witryny będzie więc wyglądać tak: https://sites.google.com/a/example.com/my-site-title.

Jeśli witryna zostanie utworzona, serwer odpowie obiektem SiteEntry zawierającym elementy dodane przez serwer: link do witryny, link do pliku danych ACL witryny, nazwę witryny, tytuł, podsumowanie itp.

Kopiowanie witryny

Uwaga: ta funkcja jest dostępna tylko w domenach G Suite.

Kopiowanie witryny jest podobne do tworzenia nowej witryny. Różnica polega na tym, że w nowym elemencie SiteEntry musisz ustawić link, który zawiera link do samego siebie witryny, którą chcesz zduplikować. Oto przykład duplikowania witryny utworzonej w sekcji Tworzenie nowych witryn:

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

Ważne kwestie:

• Można kopiować tylko witryny i szablony witryn, których właścicielem jest uwierzytelniony użytkownik.
• Możesz też skopiować szablon witryny. Witryna jest szablonem, jeśli na stronie ustawień Witryn Google zaznaczona jest opcja „Opublikuj tę witrynę jako szablon”.
• Możesz skopiować witrynę z innej domeny, o ile jesteś właścicielem witryny źródłowej.

Aktualizowanie metadanych witryny

Aby zmienić nazwę witryny, jej motyw, tag kategorii lub podsumowanie, musisz najpierw pobrać SiteEntry zawierający daną witrynę, zmodyfikować co najmniej 1 właściwość, a następnie wywołać metodę update() obiektu SiteEntry. W tym przykładzie zmieniamy motyw poprzedniej witryny i zmieniamy jej nazwę:

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

Mapowania adresów internetowych

Mapowania adresów internetowych umożliwiają użytkownikom Witryn mapowanie własnych domen na Witrynę Google. Na przykład zamiast http://sites.google.com/a/domain.com/mysite możesz użyć http://www.mydomainsite.com. W zależności od tego, gdzie jest hostowana Twoja witryna, możesz ręcznie modyfikować mapowania adresów internetowych witryny. Więcej informacji znajdziesz w tym artykule w Centrum pomocy.

Pobieranie mapowań adresu internetowego witryny

Aby zwrócić mapowania adresu internetowego witryny, pobierz wpis/plik danych witryny z parametrem with-mappings=true:

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

Istniejące mapowania będą wyświetlane jako link z atrybutem rel='webAddressMapping'. Na przykład w powyższym przykładzie są 3 webAddressMapping, które prowadzą do witryny http://sites.google.com/site/myOtherTestSite.

Modyfikowanie mapowań adresów internetowych

Uwaga: podczas pracy z mapowaniami adresów internetowych wszystkie operacje GET/POST/PUT powinny określać parametr with-mappings=true. Jeśli parametru nie ma, w przypadku wpisów w witrynie nie będą zwracane wartości webAddressMappings (GET) ani nie będą one brane pod uwagę podczas aktualizowania lub usuwania (PUT) mapowań z wpisu.

Aby dodać, zaktualizować lub usunąć mapowanie, po prostu określ, zmień lub usuń taki link podczas tworzenia nowych witryn lub aktualizowania metadanych witryny. Parametr with-mappings=true musi być uwzględniony w identyfikatorze URI pliku danych o witrynie. Uwaga: aby zaktualizować mapowania adresów, musisz być administratorem witryny lub administratorem domeny w przypadku witryny hostowanej w G Suite.

Na przykład poniższa prośba aktualizuje mapowanie http://www.mysitemapping.com na http://www.my-new-sitemapping.com i usuwa http://www.mysitemapping2.com, pomijając link w pozycji:

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

Pamiętaj, że mapowania adresów internetowych można też określić podczas tworzenia lub kopiowania witryny.

Powrót do góry

Obszar aktywności

Aby pobrać najnowszą aktywność (zmiany) w witrynie, pobierz plik danych o aktywności. Każdy wpis w kanale aktywności zawiera informacje o zmianie wprowadzonej w witrynie.

Aby wysłać zapytanie do karty aktywności, wyślij żądanie HTTP GET na adres URL karty aktywności:

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

W kliencie Java użyj klasy ActivityFeed, aby zwrócić obiekty ActivityEntry:

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

Uwaga: aby mieć dostęp do tego pliku danych, musisz być współpracownikiem lub właścicielem witryny. Klient musi uwierzytelniać się za pomocą tokena AuthSub, OAuth lub ClientLogin. Zobacz Uwierzytelnianie w usłudze Witryny.

Powrót do góry

Plik danych z wersjami

Aby pobrać historię zmian dowolnego wpisu treści, wyślij żądanie HTTP GET do linku do wersji wpisu:

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

W tym przykładzie wysyłamy zapytanie do źródła treści, a następnie pobieramy plik danych o zmianach dla pierwszego wpisu treści:

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

Uwaga: aby mieć dostęp do tego pliku danych, musisz być współpracownikiem lub właścicielem witryny. Klient musi uwierzytelniać się za pomocą tokena AuthSub, OAuth lub ClientLogin. Zobacz Uwierzytelnianie w usłudze Witryny.

Powrót do góry

Źródło treści

Pobieranie źródła treści

Źródło treści zawiera najnowsze treści z witryny. Możesz uzyskać do niego dostęp, wysyłając żądanie HTTP GET na adres URL źródła treści:

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

Przykład pobierania źródła treści:

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

Wynikowy obiekt contentFeed to obiekt ContentFeed zawierający odpowiedź z serwera. Każdy wpis w contentFeed reprezentuje inną stronę lub element w witrynie użytkownika. Obiekt ContentFeed będzie zawierać różne typy obiektów, które dziedziczą z obiektu BaseContentEntry: ListItemEntry, ListPageEntry, AttachmentEntry, WebAttachmentEntry, FileCabinetPageEntry, AnnouncementsPageEntry, AnnouncementEntry, WebPageEntry, CommentEntry.

Oto przykład listy różnych typów wpisów w ContentFeed. Każdy typ wpisu zawiera różne właściwości, ale nie wszystkie są tu wymienione.

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

Uwaga: ten plik danych może wymagać uwierzytelnienia lub nie, w zależności od uprawnień do udostępniania witryny. Jeśli witryna jest niepubliczna, klient musi uwierzytelnić się za pomocą tokena AuthSub, OAuth lub ClientLogin. Zobacz artykuł Uwierzytelnianie w usłudze Witryny.

Przykłady zapytań dotyczących źródła treści

Plik danych możesz przeszukiwać za pomocą niektórych standardowych parametrów zapytań interfejsu Google Data API oraz parametrów specyficznych dla interfejsu Sites API w wersji klasycznej. Szczegółowe informacje i pełną listę obsługiwanych parametrów znajdziesz w przewodniku.

Uwaga: w przykładach w tej sekcji użyto metody buildContentFeedUrl() opisanej w artykule Pobieranie pliku danych o treści.

Pobieranie określonych rodzajów wpisów

Aby pobrać tylko określony typ wpisu, użyj parametru kind. Ten przykład zwraca tylko attachment pozycji:

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

Aby zwrócić więcej niż 1 typ wpisu, oddziel każdy z nich znakiem kind. Ten przykład zwraca wpisy filecabinet i listpage:

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

Pobieranie strony według ścieżki

Jeśli znasz ścieżkę względną strony w Witrynach Google, możesz użyć parametru path, aby pobrać tę konkretną stronę. Ten przykład zwróci stronę znajdującą się pod adresem 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());
}

Pobieranie wszystkich wpisów na stronie nadrzędnej

Jeśli znasz identyfikator wpisu treści na stronie (np. „1234567890” w przykładzie poniżej), możesz użyć parametru parent, aby pobrać wszystkie wpisy podrzędne (jeśli takie istnieją):

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

Dodatkowe parametry znajdziesz w przewodniku.

Powrót do góry

Tworzenie treści

Uwaga: zanim utworzysz treści dla witryny, upewnij się, że została ona skonfigurowana w usłudze.
client.site = "siteName";

Nowe treści (strony internetowe, strony z listami, strony z szafkami na pliki, strony z ogłoszeniami itp.) można tworzyć, wysyłając żądanie HTTP POSTdo źródła treści:

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

Listę obsługiwanych typów węzłów znajdziesz w parametrze kind w Przewodniku.

Tworzenie nowych elementów lub stron

W tym przykładzie tworzymy nowy element webpage w domenie najwyższego poziomu witryny, dodajemy kod XHTML do treści strony i ustawiamy tytuł nagłówka na „Nowy tytuł strony internetowej”:

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

Jeśli żądanie zostanie wykonane, createdEntry będzie zawierać kopię wpisu utworzonego na serwerze.

Tworzenie produktów lub stron w ramach niestandardowych ścieżek adresów URL

Domyślnie poprzedni przykład zostanie utworzony pod adresem URLhttp://sites.google.com/site/siteName/new-webpage-title i będzie miał nagłówek strony „New Webpage Title”. Oznacza to, że w adresie URL znak <atom:title> jest normalizowany do new-webpage-title. Aby dostosować ścieżkę adresu URL strony, możesz ustawić element <sites:pageName>.

W tym przykładzie tworzona jest nowa strona filecabinet z nagłówkiem „File Storage”, ale strona jest tworzona pod adresem URL http://sites.google.com/site/siteName/files (zamiast http://sites.google.com/site/siteName/file-storage) przez określenie elementu <sites:pageName>.

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

Serwer stosuje te reguły pierwszeństwa przy nadawaniu nazwy ścieżce adresu URL strony:

1. <sites:pageName>, jeśli występuje. Musi spełniać warunek a-z, A-Z, 0-9, -, _.
2. <atom:title> nie może mieć wartości null, jeśli nie ma parametru pageName. Normalizacja polega na przycięciu i zwinięciu białych znaków do „-” oraz usunięciu znaków niezgodnych z wzorcem a-z, A-Z, 0-9, -, _.

Tworzenie podstron

Aby utworzyć podstrony (strony podrzędne) pod stroną nadrzędną, musisz ustawić link do strony nadrzędnej we wpisie. atrybut href linku do linku własnego węzła nadrzędnego.

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

Powyższy przykład tworzy nowy element announcement na pierwszej stronie z aktualnościami znalezionej w źródle treści użytkownika. Tytuł ogłoszenia to „Impreza!!”, a treść to „U mnie w ten weekend”.

Szablony stron

Tworzenie szablonów stron

Proces tworzenia szablonu strony jest taki sam jak tworzenie nowych elementów lub stron i tworzenie podstron.Różnica polega na dodaniu category z terminem i etykietą ustawionymi odpowiednio na „http://schemas.google.com/g/2005#template” i „template”.

W tym przykładzie tworzymy nowy szablon webpage.

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

Tworzenie stron na podstawie szablonu

Podobnie jak w przypadku tworzenia szablonów stron, możesz utworzyć instancję nowej strony na podstawie szablonu, umieszczając element <link> z atrybutem rel='http://schemas.google.com/sites/2008#template' wskazującym na link własny szablonu strony.

W tym przykładzie tworzymy nowy szablon filecabinet, a następnie na jego podstawie tworzymy nową stronę filecabinet.

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

Uwaga: mimo że szablon definiuje <category>, musisz go uwzględnić w swoim zgłoszeniu. Pamiętaj też, że jeśli dodasz element <content>, serwer go odrzuci.

przesyłanie plików;

Podobnie jak w Witrynach Google interfejs API obsługuje przesyłanie załączników do strony magazynu plików lub strony nadrzędnej.

Aby przesłać załącznik do elementu nadrzędnego, wyślij żądanie HTTP POST na adres URL źródła treści:

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

Wszystkie typy załączników muszą być przesłane na stronę nadrzędną. Dlatego ustawiasz link do elementu nadrzędnego w obiekcie AttachmentEntry lub WebAttachmentEntry, który chcesz przesłać. Więcej informacji znajdziesz w artykule Tworzenie podstron.

Przesyłam załączniki

W tym przykładzie plik PDF jest przesyłany do pierwszego elementu FileCabinetPageEntry znalezionego w źródle treści użytkownika. Załącznik zostanie utworzony z tytułem „Getting Started” i (opcjonalnym) opisem „HR packet”.

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

Jeśli przesyłanie się powiedzie, attachment będzie zawierać kopię utworzonego wpisu załącznika.

Przesyłanie załącznika do folderu

Aby przesłać załącznik do istniejącego folderu w FileCabinetPageEntry, dodaj kategorię z atrybutem „term” ustawionym na nazwę folderu. Na przykład dodaj ten wiersz w uploadAttachment():

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

Załączniki internetowe

Załączniki internetowe to specjalny rodzaj załączników. Są to linki do innych plików w internecie, które możesz dodać do swoich ofert w szafie na dokumenty. Ta funkcja jest analogiczna do metody przesyłania „Dodaj plik według adresu URL” w interfejsie Witryn Google.

Uwaga: załączniki internetowe można tworzyć tylko w magazynie plików. Nie można ich przesyłać na inne typy stron.

W tym przykładzie tworzony jest element WebAttachmentEntry pod pierwszym elementem FileCabinetPageEntry znalezionym w źródle treści użytkownika. Jej tytuł i (opcjonalny) opis są ustawione odpowiednio na „GoogleLogo” i „nice colors”.

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

Pole POST tworzy w szafce plików użytkownika link do obrazu znajdującego się pod adresem „http://www.google.com/images/logo.gif”.

Powrót do góry

Aktualizowanie treści

Aktualizowanie metadanych strony lub treści HTML

Metadane (tytuł, nazwa strony itp.) i treść strony dowolnego typu BaseContentEntry można edytować za pomocą metody update() wpisu. Spowoduje to wysłanie żądania HTTP PUT do editlinku wpisu.

Poniżej znajdziesz przykład aktualizacji ListPageEntry z uwzględnieniem tych zmian:

• Tytuł zostanie zmieniony na „Zaktualizowany tytuł”.
• Zawartość HTML strony zostanie zaktualizowana do wartości „<p>Updated HTML Content</p>”.
• Nagłówek pierwszej kolumny listy zmieni się na „Właściciel”.

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

Aktualizowanie zawartości pliku z przyłączeniem

W przypadku AttachmentEntry możesz też zaktualizować treść, ustawiając MediaSource wpisu, a następnie używając metody updateMedia(boolean) wpisu.

Ten przykład zaktualizuje zawartość istniejącego załącznika:

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

W przykładzie wysyłane jest żądanie HTTP PUT do linku edit-media wpisu. Zwrócony plik AttachmentEntry będzie zawierać zaktualizowaną treść.

Aktualizowanie metadanych i treści załącznika

Możesz zaktualizować metadane załącznika i jego zawartość w tym samym wywołaniu, korzystając z metody updateMedia(). Możesz zaktualizować tylko treść pliku, tylko metadane lub jedno i drugie.

W tym przykładzie zmieniamy tytuł załącznika na „Nowy tytuł”, aktualizujemy jego opis i zastępujemy zawartość pliku nowym plikiem ZIP. Żądanie zawiera nową zawartość pliku, dlatego używany jest updateMedia() AttachmentEntry.

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

Powrót do góry

Usuwanie treści

Aby usunąć stronę lub element z witryny Google, najpierw pobierz wpis treści, a potem wywołaj funkcję delete().

entry.delete();

Możesz też użyć metody delete() klasy usługi, przekazując jej link edit do wpisu i wartość ETag:

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

Jeśli wpis został usunięty, serwer odpowie kodem HTTP 200 OK.

Powrót do góry

Pobieranie załączników

Aby pobrać AttachmentEntry, wyślij żądanie HTTP GET do linku src treści wpisu.

Ten przykład pobiera pierwszy plik AttachmentEntry znaleziony w źródle treści użytkownika do katalogu „/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.");

Powrót do góry

Plik danych ACL

Omówienie uprawnień do udostępniania (list ACL)

Każdy wpis na liście kontroli dostępu w pliku danych ACL reprezentuje rolę dostępu konkretnego podmiotu, czyli użytkownika, grupy użytkowników, domeny lub domyślnego dostępu (który jest witryną publiczną). Pozycje będą wyświetlane tylko w przypadku podmiotów z wyraźnym dostępem – dla każdego adresu e-mail w panelu „Osoby z dostępem” na ekranie udostępniania w interfejsie użytkownika Witryn Google będzie wyświetlana jedna pozycja. Dlatego administratorzy domeny nie będą widoczni, mimo że mają domyślny dostęp do witryny.

Role

Element role reprezentuje poziom dostępu, jaki może mieć encja. Element gAcl:role może przyjmować 4 wartości:

• odczytujący – przeglądający (odpowiednik dostępu tylko do odczytu);
• edytujący – współpracownik (odpowiednik uprawnień do zapisu i odczytu);
• właściciel – zwykle administrator witryny (odpowiednik uprawnień do odczytu i zapisu);

Zakresy

Element zakresu reprezentuje podmiot, który ma ten poziom dostępu. Element gAcl:scope może mieć 4 typy:

• user – wartość adresu e-mail, np. „user@gmail.com”.
• group – adres e-mail Grupy dyskusyjnej Google, np. „group@domain.com”.
• domain – nazwa domeny G Suite, np. „domena.com”.
• default – istnieje tylko jeden możliwy zakres typu „default”, który nie ma wartości (np.<gAcl:scope type="default">). Ten konkretny zakres kontroluje dostęp, jaki każdy użytkownik ma domyślnie w przypadku witryny publicznej.

Uwaga: domeny nie mogą mieć wartości gAcl:role ustawionej na dostęp „właściciel”, mogą mieć tylko dostęp „czytelnik” lub „edytujący”.

Pobieranie pliku danych ACL

Klasy AclFeed i AclEntry umożliwiają kontrolowanie uprawnień do udostępniania witryny. Można je pobrać za pomocą metody getFeed() klasy usługi.

Ten przykład pobiera plik danych listy kontroli dostępu dla danej witryny i wyświetla uprawnienia każdego 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');

Jeśli pracujesz z wpisami w SiteFeed, każdy SiteEntry zawiera link do pliku danych ACL. Na przykład ten fragment kodu pobiera plik danych ACL z SiteEntry:

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

Udostępnianie witryny

Uwaga: niektóre listy ACL udostępniania mogą być możliwe tylko wtedy, gdy domena jest skonfigurowana tak, aby zezwalać na takie uprawnienia (np. jeśli w przypadku domen G Suite włączone jest udostępnianie poza domenę).

Aby udostępnić Witrynę Google za pomocą interfejsu API, klient musi utworzyć nowy AclEntry i POST go na serwerze.

Oto przykład dodania adresu „user@example.com” jako reader w witrynie:

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

Możliwe wartości AclScope i AclRoles znajdziesz w sekcji Omówienie pliku danych ACL.

Udostępnianie na poziomie grupy i domeny

Podobnie jak w przypadku udostępniania witryny pojedynczemu użytkownikowi, możesz udostępnić witrynę grupie dyskusyjnej Google lub domenie G Suite.

Udostępnianie na adres e-mail grupy:

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

Udostępnianie całej domenie:

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

Udostępnianie na poziomie domeny jest obsługiwane tylko w przypadku domen G Suite i tylko w przypadku domeny, w której hostowana jest witryna. Na przykład witryna http://sites.google.com/a/domena1.com/witrynaA może udostępniać całą witrynę tylko domenie domena1.com, a nie domenie domena2.com. Witryny, które nie są hostowane w domenie G Suite (np. http://sites.google.com/site/witrynaB), nie mogą zapraszać domen.

Modyfikowanie uprawnień do udostępniania

Aby zmienić istniejące uprawnienia do udostępniania w witrynie, najpierw pobierz odpowiedni AclEntry, zmodyfikuj uprawnienia zgodnie z potrzebami, a następnie wywołaj metodę update() obiektu AclEntry, aby zmodyfikować listę ACL na serwerze.

W tym przykładzie modyfikujemy poprzedni przykład aclEntry z sekcji Udostępnianie witryny, zmieniając „user@example.com” na writer (współpracownik):

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

Więcej informacji o tagach ETag znajdziesz w przewodniku po interfejsach API danych Google.

Usuwanie uprawnień do udostępniania

Aby usunąć uprawnienie do udostępniania, najpierw pobierz obiekt AclEntry, a potem wywołaj jego metodę delete():

aclEntry.delete();

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

Więcej informacji o tagach ETag znajdziesz w przewodniku po interfejsach API danych Google.

Powrót do góry

Tematy specjalne

Ponowne pobieranie kanału lub wpisu

Jeśli chcesz pobrać plik danych lub wpis, który został już wcześniej pobrany, możesz zwiększyć wydajność, informując serwer, aby wysyłał listę lub wpis tylko wtedy, gdy uległy one zmianie od czasu ostatniego pobrania.

Aby wykonać takie warunkowe pobieranie, metody getFeed() i getEntry() udostępniają dodatkowy argument, który akceptuje wartość ETag lub obiekt DateTime dla nagłówka If-Modified-Since. Dostęp do tagu ETag wpisu możesz uzyskać z poziomu entry.getEtag().

W tym przykładzie warunkowo pobierany jest wpis strony internetowej z treścią:

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

Gdy serwer otrzyma to żądanie, sprawdzi, czy żądany element ma ten sam tag ETag co tag ETag, który został przez Ciebie określony. Jeśli tagi ETag są zgodne, oznacza to, że element nie uległ zmianie, a serwer zwraca wyjątek HTTP 304 NotModifiedException.

Jeśli tagi ETag nie pasują do siebie, oznacza to, że od ostatniego żądania element został zmodyfikowany, a serwer zwraca element.

Więcej informacji o tagach ETag znajdziesz w przewodniku po interfejsach API danych Google.

Powrót do góry