Przewodnik po języku Java

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

Interfejs API danych Witryn Google umożliwia aplikacjom klienckim uzyskiwanie dostępu do treści w Witrynach Google oraz publikowanie i modyfikowanie jej zawartości. Aplikacja kliencka może również prosić o listę ostatniej aktywności, pobrać historię zmian i pobrać załączniki.

Poza ogólnymi informacjami o możliwościach interfejsu Sites Data API w tym przewodniku znajdziesz przykłady interakcji z tym interfejsem API. korzystając z biblioteki klienta Java. Aby uzyskać pomoc przy konfigurowaniu biblioteki klienta, zobacz Pierwsze kroki z biblioteką klienta Java Data Google Jeśli interesuje Cię aby dowiedzieć się więcej o podstawowym protokole używanym przez bibliotekę klienta w języku Java do interakcji z interfejsem API klasycznej wersji Witryn, zapoznaj się z artykułem przewodnika po protokołach.

Odbiorcy

Ten dokument jest przeznaczony dla programistów, którzy chcą pisać aplikacje klienckie obsługujące Witryny Google. korzystając z biblioteki klienta w języku Java od Google Data.

Pierwsze kroki

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

Instalowanie biblioteki

Informacje o konfigurowaniu i instalowaniu biblioteki klienta znajdziesz w artykule Pierwsze kroki z biblioteką klienta w języku Java od Google. Jeśli używasz Eclipse, w tym artykule jak skonfigurować projekt, korzystając z wtyczki Google Data APIs Eclipse. Aby rozpocząć, wykonaj następujące czynności:

1. Zainstaluj środowisko Java w wersji 1.5 lub nowszej
2. Pobierz bibliotekę klienta (najnowszą wersję aplikacji 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 interfejsu API klasycznej wersji Witryn.
2. java/lib/gdata-core-1.0.jar
3. java/lib/gdata-client-1.0.jar
4. java/lib/gdata-spreadsheet-3.0.jar (w przypadku pracy ze stronami lub elementami listy)

Pamiętaj też, aby dołączyć 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 pobieranego pliku gdata-samples.java.zip. Źródło jest też dostępne pod adresem /trunk/java/sample/sites/ w repozytorium SVN dostępnym z karty Source (Źródło). SitesDemo.java umożliwia użytkownikowi wykonanie różnych operacji, które pokazują, jak korzystać z klasycznego interfejsu Sites API.

Uwaga: aby uruchomić próbkę, musisz dodać atrybut java/sample/util/lib/sample-util.jar.

Rozpoczynanie własnego projektu

Wskazówka: aby szybko skonfigurować ją za pomocą wtyczki Eclipse, zapoznaj się z artykułem Używanie Eclipse z interfejsami API danych Google.

W zależności od potrzeb aplikacji będziesz potrzebować kilku importów. Zalecamy zacząć 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 klasycznym interfejsem Sites API:

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

Argument applicationName powinien mieć format: company-applicationname-version. Ten parametr jest używany do logowania.

Uwaga: w pozostałej części tego przewodnika przyjęto założenie, że w zmiennej client został utworzony SitesService.

Uwierzytelnianie w klasycznym interfejsie Sites API

Biblioteki klienta w Javie można używać do pracy z publicznymi lub prywatnymi kanałami. Interfejs Sites Data API zapewnia dostęp do prywatnych i publicznych danych. w zależności od uprawnień do Witryn i operacji, którą chcesz wykonać. Możesz na przykład odczytać źródło treści witryny publicznej, ale bez wprowadzania w niej aktualizacji, co wymagałoby uwierzytelnionego klienta. Można to zrobić za pomocą Uwierzytelnianie ClientLogin do nazwy użytkownika i hasła, AuthSub lub OAuth.

Więcej informacji o protokole AuthSub, OAuth i ClientLogin znajdziesz w artykule Omówienie uwierzytelniania interfejsów API danych Google.

Wskazówka: interfejs API obsługuje protokół SSL (HTTPS). Jeśli używasz AuthSub/OAuth, określ zakresu https://sites.google.com/feeds/, aby przesyłać żądania plików danych przez SSL. Pamiętaj też, że w przypadku domeny G Suite, „Wymagaj SSL” w administracyjnym panelu sterowania jest respektowane przez interfejs API. Możesz wymusić na wszystkich Żądania API są przesyłane przez HTTPS przez wywołanie metody client.useSsl();.

AuthSub dla aplikacji internetowych

Uwierzytelnianie AuthSub dla 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 ani hasła dla użytkownika Witryn Google – wystarczy Token AuthSub jest wymagany.

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

Protokół OAuth na potrzeby aplikacji internetowych lub zainstalowanych/mobilnych

Alternatywą dla protokołu AuthSub jest protokół OAuth. Jest on przeznaczony dla aplikacji internetowych. Protokół OAuth jest podobny do korzystania z trybu bezpiecznego i zarejestrowanego AuthSub. W tym fakcie, że wszystkie wnioski o przekazanie danych muszą być podpisane cyfrowo i musisz zarejestrować swoją domenę.

ClientLogin dla zainstalowanych/mobilnych aplikacji

Konta ClientLogin powinny używać zainstalowane lub mobilne aplikacje, 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 przypadku kolejnych próśb pojawia się odwołanie do tokena uwierzytelniania.

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

Powrót do góry

Kanał witryny

Kanał witryn może służyć do tworzenia listy witryn Google należących do użytkownika lub do wyświetlania, do których ma uprawnienia do wyświetlania. W ten sposób możesz też zmienić nazwę istniejącej witryny. W przypadku domen G Suite można też za jej pomocą utworzyć lub skopiować całą witrynę.

Witryny z ofertami

Aby wysłać zapytanie dotyczące kanału witryny, wyślij żądanie HTTP GET na adres URL tego kanału:

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

W kliencie Java możesz używać klas SiteFeed i SiteEntry. z kanałem witryny:

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 zawiera tytuł i nazwę witryny oraz jej motyw. Dostępne są inne moduły pobierania dla 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.

Możesz udostępnić nowe witryny przez utworzenie nowego obiektu SiteEntry i wywołanie metody klienta insert() w kanale witryny.

W tym przykładzie tworzona jest zupełnie nowa witryna z motywem „Slate” (ustawienie opcjonalne) i zapewnia nazwa witryny (wymagana) i opis (opcjonalnie);

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ższe żądanie 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/tytuł-mojej-witryny.

Po utworzeniu witryny serwer w odpowiedzi przesyła SiteEntry zawiera elementy dodane przez serwer: link do witryny, link do kanału listy kontroli dostępu witryny (ACL), nazwa witryny, tytuł, podsumowanie itd.

Kopiowanie witryny

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

Kopiowanie witryny przebiega podobnie do tworzenia nowej witryny. Różnica polega na tym, że musisz ustawić w nowym SiteEntry, który zawiera link własny do duplikatu. 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 informacje:

• Kopiowane mogą być tylko witryny i szablony witryn należące do uwierzytelnionego użytkownika.
• Możesz też skopiować szablon witryny. Witryna jest szablonem, jeśli opcja „Opublikuj tę witrynę jako szablon” jest zaznaczona na stronie ustawień Witryn Google.
• Możesz skopiować witrynę z innej domeny, dopóki nie staniesz się jej właścicielem w witrynie źródłowej.

Aktualizowanie metadanych witryny

Aby zmienić nazwę witryny albo jej motyw, tag kategorii lub podsumowanie, musisz najpierw pobrać plik SiteEntry zawierający tę witrynę. modyfikuj co najmniej jedną właściwość, a potem wywołaj metodę update() funkcji SiteEntry. W tym przykładzie modyfikuje się motyw poprzedniej witryny i zmienia 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 pozwalają użytkownikom Witryn mapować własne domeny na Witryny Google. Na przykład: http://www.mydomainsite.com zamiast http://sites.google.com/a/domain.com/mysite. W zależności od miejsca hostowania witryny możesz ręcznie modyfikować mapowania adresów internetowych witryny. Więcej informacji znajdziesz w Centrum pomocy.

Pobieranie mapowań adresów internetowych witryny

Aby zwrócić mapowanie adresu internetowego witryny, pobierz wpis lub kanał 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 parametrem rel='webAddressMapping'. W przykładzie powyżej są 3 komponenty webAddressMapping, które wskazują tę witrynę http://sites.google.com/site/myOtherTestSite

Modyfikowanie mapowania adresów internetowych

Uwaga: wszystkie operacje GET/POST/PUT powinny mieć określony parametr with-mappings=true. za pomocą mapowania adresów internetowych. Jeśli parametr nie ma wartości, parametry webAddressMapping nie są zwracane we wpisach witryny (GET) ani nie są uwzględniane podczas aktualizowania/usuwania mapowań (PUT) z wpisu.

Aby dodać, zaktualizować lub usunąć mapowanie, wystarczy określić, zmienić lub usunąć taki link podczas tworzenia nowych witryn lub aktualizacji metadanych witryny. W identyfikatorze URI kanału witryny należy umieścić parametr with-mappings=true. Uwaga: aby zaktualizować mapowanie adresów, musisz być administratorem witryny lub administratora domeny w przypadku witryny hostowanej w G Suite.

Na przykład poniższe żądanie aktualizuje mapowanie http://www.mysitemapping.com na http://www.my-new-sitemapping.com, i usuwa http://www.mysitemapping2.com, pozostawiając link poza wpisem:

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 adresu internetowego można też określić podczas tworzenia lub kopiowania witryny.

Powrót do góry

Obszar aktywności

Możesz pobrać ostatnią aktywność (zmiany) w witrynie, pobierając kanał aktywności. Każda pozycja w kanał aktywności zawiera informacje o zmianie wprowadzonej w witrynie.

Aby wysłać zapytanie dotyczące kanału aktywności, wyślij żądanie HTTP GET na adres URL kanału 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 uzyskać dostęp do tego kanału, musisz być współpracownikiem lub właścicielem witryny. Twój klient musi uwierzytelniać się przy użyciu tokena AuthSub, OAuth lub ClientLogin. Zobacz Uwierzytelnianie w usłudze Witryny.

Powrót do góry

Kanał wersji

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

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

W tym przykładzie odpytujemy plik danych o treści, a następnie pobieramy plik danych o wersjach pierwszego wpisu:

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 uzyskać dostęp do tego kanału, musisz być współpracownikiem lub właścicielem witryny. Twój klient musi uwierzytelniać się przy użyciu tokena AuthSub, OAuth lub ClientLogin. Zobacz Uwierzytelnianie w usłudze Witryny.

Powrót do góry

Źródło treści

Pobieram źródło treści

Źródło treści zawiera listę najnowszych treści w witrynie. Dostęp do niego można uzyskać, 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);

Powstały w ten sposób obiekt contentFeed to obiekt ContentFeed zawierający odpowiedź z serwera. Każdy wpis z contentFeed oznacza inną stronę lub inny element w witrynie użytkownika. Pole ContentFeed będzie zawierać różne typy obiektów, wszystkie odziedziczone z grupy BaseContentEntry: ListItemEntry, ListPageEntry, AttachmentEntry, WebAttachmentEntry, FileCabinetPageEntry, AnnouncementsPageEntry, AnnouncementEntry, WebPageEntry, CommentEntry.

Oto przykład wyświetlania różnych typów wpisów w elemencie ContentFeed. Każdy typ wpisu ma inne właściwości, ale nie wszystkie są tu wydrukowane.

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, ale nie musi. w zależności od uprawnień do udostępniania w witrynie. Jeśli witryna nie jest publiczna, klient musi uwierzytelnić się przy użyciu tokena AuthSub, OAuth lub ClientLogin. Zobacz Uwierzytelnianie w usłudze Witryny.

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

Źródło treści możesz przeszukiwać, korzystając ze standardowych parametrów zapytania w interfejsie Google Data API. i tych związanych z interfejsem klasycznej wersji Witryn. Szczegółowe informacje i pełną listę obsługiwanych parametrów znajdziesz tutaj: Przewodnik informacyjny

Uwaga: w przykładach w tej sekcji używana jest metoda buildContentFeedUrl() z sekcji Pobieranie pliku danych.

Pobieranie określonych rodzajów wpisów

Aby pobrać tylko konkretny typ wpisu, użyj parametru kind. Ten przykład zwraca tylko tyle wpisów: attachment:

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żdą część kind znakiem „,”. Ten przykład zwraca filecabinet i listpage wpisów:

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 względną ścieżkę strony w Witrynach Google, możesz użyć parametru path, by ją pobrać. 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 ze strony nadrzędnej

Jeśli znasz identyfikator wpisu treści strony (np. „1234567890” w przykładzie poniżej), możesz użyć parametru parent pobierz wszystkie jej wpisy podrzędne (jeśli występują):

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ść witryny, skonfiguruj ją w kliencie.
client.site = "siteName";

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

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

Listę typów węzłów obsługujących znajdziesz w opisie parametru kind w Przewodniku.

Tworzenie nowych elementów / stron

W tym przykładzie tworzony jest nowy webpage w sekcji najwyższego poziomu witryny, który zawiera fragment XHTML dla treści strony i ustawia tytuł nagłówka na „Tytuł nowej 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 zrealizowane, createdEntry będzie zawierać kopię wpisu utworzonego na serwerze.

Tworzenie elementów/stron w niestandardowych ścieżkach URL

Domyślnie poprzedni przykład jest tworzony pod adresem URL. http://sites.google.com/site/siteName/new-webpage-title i mają nagłówek „Tytuł nowej strony internetowej”. Oznacza to, że w przypadku adresu URL <atom:title> jest znormalizowany do new-webpage-title. Aby dostosować ścieżkę adresu URL strony, możesz ustawić element <sites:pageName>.

W tym przykładzie tworzymy nową stronę filecabinet z nagłówkiem „Przechowywanie plików”, ale tworzymy stronę z 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 używa następujących reguł pierwszeństwa przy nazywaniu ścieżki adresu URL strony:

1. <sites:pageName> (jeśli występuje). Wymagana jest wartość w polu a-z, A-Z, 0-9, -, _.
2. <atom:title>, jeśli parametr pageName nie jest podany, nie może mieć wartości null. Normalizacja polega na przycięciu i zwijaniu odstępów do znaku „-” oraz usuń znaki, które nie pasują do a-z, A-Z, 0-9, -, _.

Tworzenie podstron

Aby utworzyć podstrony (strony podrzędne) w ramach strony nadrzędnej, musisz we wpisie ustawić link nadrzędny. Atrybut href linku do funkcji własny link 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());

W powyższym przykładzie tworzymy nowy element announcement na pierwszej stronie z powiadomieniami znalezioną w polu w źródle treści użytkownika. Tytuł ogłoszenia to „Impreza!” a zawartość sekcji „Moje miejsce, 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 elementu category z hasłem i etykietą „http://schemas.google.com/g/2005#template”. i „szablon”.

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 szablonów stron, możesz utworzyć nową instancję na podstawie szablonu, dodając atrybut <link> z atrybutem rel='http://schemas.google.com/sites/2008#template' wskazywanie do linku do siebie w szablonie strony.

W tym przykładzie tworzymy nowy szablon filecabinet, a następnie na jego podstawie tworzy 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: pomimo szablonu, który określa atrybut <category>, w którym znajduje się nadal jest wymagany. Pamiętaj też, że jeśli dodasz element <content>, serwer go odrzuci.

Przesyłanie plików

Podobnie jak w przypadku Witryn Google interfejs API obsługuje przesyłanie załączników na stronie magazynu plików lub na stronie nadrzędnej.

Aby przesłać załącznik do elementu nadrzędnego, wyślij żądanie HTTP POST na adres URL pliku danych:

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

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

Przesyłam załączniki

W tym przykładzie prześlesz plik PDF do pierwszego elementu FileCabinetPageEntry znalezionego w źródle treści użytkownika. Zostanie utworzony załącznik o tytule „Pierwsze kroki” i (opcjonalnie) opis „Pakiet HR”.

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ę uda, attachment będzie zawierać kopię utworzonego załącznika.

Przesyłanie załącznika do folderu

Aby przesłać załącznik do istniejącego folderu w folderze FileCabinetPageEntry, uwzględnij kategorię z „hasłem” z nazwą folderu. Na przykład dodaj ten wiersz w pliku uploadAttachment():

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

Załączniki internetowe

Załączniki internetowe to szczególne rodzaje załączników. Zasadniczo są to linki do innych plików w internecie które możesz dodać do listy magazynowej. Ta funkcja działa analogicznie do opcji „Dodaj plik według adresu URL” przesyłania w interfejsie Witryn Google.

Uwaga: załączniki internetowe można tworzyć tylko w magazynie plików. Nie można ich przesyłać na strony innego typu.

W tym przykładzie tworzony jest element WebAttachmentEntry poniżej pierwszego elementu FileCabinetPageEntry znalezionego w źródle treści użytkownika. Jej tytuł i (opcjonalny) opis mają wartość „GoogleLogo” i „ładne kolory”.

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

Element POST tworzy w magazynie plików użytkownika link prowadzący do obrazu pod adresem „http://www.google.com/images/logo.gif”.

Powrót do góry

Aktualizowanie treści

Aktualizowanie metadanych strony i/lub treści HTML

Metadane (tytuł, pageName itp.) oraz zawartość strony dowolnego typu BaseContentEntry mogą być edytowane przez za pomocą metody update() wpisu. Spowoduje to wysłanie żądania HTTP PUT do funkcji edit wpisu .

Poniżej znajdziesz przykład aktualizacji elementu ListPageEntry z tymi zmianami:

• Zmieniono tytuł na „Zaktualizowany tytuł”.
• Zawartość HTML strony zostanie zaktualizowana do „<p>Zaktualizowana treść HTML</p>”
• Nagłówek pierwszej kolumny listy został zmieniony 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 załącznika

W przypadku AttachmentEntry możesz również zaktualizować treść, ustawiając wartość MediaSource wpisu, a następnie za pomocą funkcji metody updateMedia(boolean) wpisu.

Ten przykład aktualizuje 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);
}

Ten przykład wysyła żądanie HTTP PUT do linku edit-media wpisu. Zwrócone wartości Plik AttachmentEntry będzie zawierać zaktualizowaną treść.

Aktualizowanie metadanych i treści załączników

Metadane załącznika i jego zawartość możesz zaktualizować w tym samym wywołaniu przy użyciu metody updateMedia(). Jeśli możesz zaktualizować tylko treść pliku, metadane lub oba te elementy.

W tym przykładzie zmieniono tytuł załącznika na „Nowy tytuł”, zmienił się jego opis i zastąpiono zawartość pliku nowym plikiem ZIP. Żądanie zawiera nową zawartość pliku, więc używany jest identyfikator updateMedia() obiektu 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

Usuwam treść

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

entry.delete();

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

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

Jeśli wpis został usunięty, serwer w odpowiedzi przesyła żądanie HTTP 200 OK.

Powrót do góry

Pobieranie załączników

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

Ten przykład umożliwia pobranie pierwszych AttachmentEntry elementów znalezionych w źródle treści użytkownika do katalogu „/ścieżka/do/zapisania/pliku/”:

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

Kanał ACL

Omówienie uprawnień do udostępniania (listy kontroli dostępu)

Każdy wpis na liście kontroli dostępu (ACL) w kanale ACL reprezentuje rolę dostępu określonego podmiotu: użytkownika, grupy użytkowników, domeny lub domyślny dostęp (witryna publiczna). Wpisy będą wyświetlane tylko dla jednostek z jawnym dostępem – wyświetli się 1 wpis dla każdego adresu e-mail w polu „People with Access” (Osoby z dostępem) na ekranie udostępniania w interfejsie Witryn Google. Administratorzy domeny nie będą wyświetlani, nawet jeśli mają bezpośredni dostęp do witryny.

Role

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

• reader – przeglądający (odpowiednik dostępu tylko do odczytu).
• writer – współpracownik (odpowiednik uprawnień do odczytu i zapisu).
• owner – zwykle jest administratorem witryny (odpowiednik uprawnień do odczytu i zapisu).

Zakresy

Element zakresu reprezentuje jednostkę, która ma dany poziom dostępu. Element gAcl:scope może zawierać 4 rodzaje:

• user – wartość adresu e-mail, np. „użytkownik@gmail.com”.
• grupa – adres e-mail grupy dyskusyjnej Google, np. „grupa@domena.com”.
• domena – nazwa domeny G Suite, np. „domena.com”.
• default – jest tylko jeden możliwy zakres typu „default”, który nie zawiera wartości; (np.<gAcl:scope type="default">). Ten konkretny zakres określa domyślnie dostęp każdego użytkownika na stronie publicznej.

Uwaga: domeny nie mogą mieć wartości gAcl:role. z ustawieniem „owner” dostęp do treści, mogą być tylko czytelnikami lub autorami.

Pobieranie pliku danych ACL

Za pomocą klas AclFeed i AclEntry można kontrolować udostępnianie witryny uprawnień i można je pobrać za pomocą metody getFeed() klasy usługi.

Poniższy przykład pobiera plik danych ACL dla danej witryny i wyświetla uprawnienia co 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 kanale SiteFeed, każdy element SiteEntry zawiera link do swojego kanału ACL. Na przykład ten fragment kodu pobiera plik danych listy kontroli dostępu (ACL) identyfikatora 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: udostępnianie określonych list kontroli dostępu (ACL) jest możliwe tylko wtedy, gdy domena jest skonfigurowana. aby zezwolić na takie uprawnienia (np. jeśli w przypadku domen G Suite udostępnianie poza domenę jest włączone).

Aby udostępnić stronę w Witrynach Google przy użyciu interfejsu API, klient musi utworzyć nowy AclEntry i POST do serwera.

Oto przykład dodania adresu „użytkownik@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);
}

W sekcji Przegląd pliku danych ACL znajdziesz możliwe AclScope i AclRoles.

Udostępnianie na poziomie grupy i domeny

Podobnie jak w przypadku udostępniania witryny jednemu użytkownikowi, możesz udostępnić ją całej Domena grupy dyskusyjnej Google lub domena G Suite.

Udostępnianie adresowi e-mail grupy:

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

Udostępnianie w 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ępnić całą witrynę tylko domenie domena1.com, a nie domena2.com. Witryny, które nie są hostowane w domenie G Suite (np. http://sites.google.com/site/siteB) nie mogą zapraszać domen.

Zmiana uprawnień do udostępniania

Aby uzyskać istniejące uprawnienia do udostępniania w witrynie, najpierw pobierz obiekt AclEntry, którego dotyczy problem, a następnie zmodyfikuj uprawnienia. zgodnie z potrzebami, a następnie wywołaj metodę update() metody AclEntry, aby zmodyfikować listę kontroli dostępu (ACL) na serwerze.

Ten przykład modyfikuje poprzedni przykład aclEntry z sekcji Udostępnianie witryny, aktualizując konto „użytkownik@example.com” jako 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ąć uprawnienia do udostępniania, najpierw pobierz obiekt AclEntry, a następnie 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ć pobrany wcześniej kanał lub wpis, możesz poprawić wydajność, mówiąc z serwera, aby wysyłał listę lub wpis tylko wtedy, gdy zmieniły się one od ostatniego pobrania.

Aby wykonać tego rodzaju pobieranie warunkowe, metody getFeed() i getEntry() zapewniają dodatkowy argument akceptujący wartość ETag lub obiekt DateTime nagłówka If-Modified-Since. Etag wpisu możesz uzyskać z entry.getEtag().

W tym przykładzie wykonywane jest warunkowe pobieranie pozycji strony z treścią:

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

Po otrzymaniu tego żądania serwer sprawdza, czy żądany element ma ten sam tag ETag, określony przez Ciebie ETag. Jeśli tagi ETag są zgodne, element nie uległ zmianie, a serwer zwraca Zostanie zgłoszony wyjątek HTTP 304 NotModifiedException.

Jeśli znaczniki ETag są różne, oznacza to, że element został zmodyfikowany od czasu ostatniego żądania, a serwer zwraca go.

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

Powrót do góry