Guida al linguaggio Java

Importante: questo documento è stato scritto prima del 2012. Le opzioni di autenticazione descritte in questo documento (OAuth 1.0, AuthSub e ClientLogin) sono state deprecate ufficialmente il 20 aprile 2012 e non sono più disponibili. Ti consigliamo di eseguire la migrazione ad OAuth 2.0 appena possibile.

L'API di dati di Google Sites consente alle applicazioni client di accedere, pubblicare e modificare i contenuti all'interno di un sito Google. La tua applicazione client può anche richiedere un elenco delle attività recenti, recuperare la cronologia delle revisioni e scaricare gli allegati.

Oltre a fornire alcune informazioni di base sulle funzionalità dell'API di dati di Sites, questa guida fornisce esempi di interazione con l'API utilizzando la libreria client Java. Per assistenza nella configurazione della libreria client, consulta la Guida introduttiva alla libreria client Java dei dati di Google. Se vuoi saperne di più sul protocollo sottostante utilizzato dalla libreria client Java per interagire con l'API della versione classica di Sites, consulta la guida ai protocolli.

Pubblico

Questo documento è destinato agli sviluppatori che desiderano scrivere applicazioni client che interagiscano con Google Sites utilizzando la libreria client Java dei dati di Google.

Come iniziare

Google Sites utilizza Account Google o account G Suite per l'autenticazione. Se hai già un account, è tutto pronto. In caso contrario, puoi creare un nuovo account.

Installazione della libreria

Per assistenza durante la configurazione e l'installazione della libreria client, consulta la Guida introduttiva alla libreria client Java dei dati di Google. Se utilizzi Eclipse, questo articolo spiega anche come configurare il tuo progetto utilizzando il plug-in Eclipse delle API di dati di Google. Ecco cosa ti serve per iniziare:

  1. Installa Java 1.5 o versioni successive
  2. Scarica la libreria client (la versione più recente di gdata-src.java.zip)
  3. Scarica l'elenco delle dipendenze
  4. Scarica le applicazioni di esempio (la versione più recente di gdata-samples.java.zip)

Dopo aver installato il file .jars, dovrai includere quanto segue nel progetto:

  1. java/lib/gdata-sites-2.0.jar: la versione 2.0 qui è destinata alla versione 1.4 dell'API della versione classica di Sites.
  2. java/lib/gdata-core-1.0.jar
  3. java/lib/gdata-client-1.0.jar
  4. java/lib/gdata-spreadsheet-3.0.jar (se lavori con pagine / elementi di elenco)

Inoltre, assicurati di includere i jar delle dipendenze (gdata-media-1.0.jar, mail.jar e google-collect....jar).

Esecuzione dell'applicazione di esempio

Un'applicazione di esempio funzionante completa si trova nella sottodirectory /java/sample/sites del download di gdata-samples.java.zip. L'origine è disponibile anche in /trunk/java/sample/sites/ nel repository SVN accessibile dalla scheda Origine. Il SitesDemo.java consente all'utente di eseguire una serie di operazioni che dimostrano come utilizzare l'API della versione classica di Sites.

Nota: per eseguire l'esempio, devi includere java/sample/util/lib/sample-util.jar.

Avvio del tuo progetto

Suggerimento: consulta l'articolo Utilizzo di Eclipse con le API di dati di Google per una configurazione rapida con il nostro plug-in Eclipse.

A seconda delle esigenze della tua applicazione, avrai bisogno di diverse importazioni. Ti consigliamo di iniziare con le seguenti importazioni:

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

Successivamente, dovrai anche configurare un oggetto SitesService, che rappresenta una connessione client all'API della versione classica di Sites:

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

L'argomento applicationName deve avere il seguente formato: company-applicationname-version. Questo parametro viene utilizzato per il logging.

Nota: la parte restante di questa guida presuppone che tu abbia creato un SitesService nella variabile client.

Autenticazione nell'API della versione classica di Sites

La libreria client Java può essere utilizzata per lavorare con feed pubblici o privati. L'API Sites Data fornisce l'accesso a feed privati e pubblici, in base alle autorizzazioni di Sites e all'operazione che stai tentando di eseguire. Ad esempio, potresti essere in grado di leggere il feed di contenuti di un sito pubblico, ma non di aggiornarlo, il che richiederebbe un client autenticato. Questa operazione può essere eseguita tramite l'autenticazione nome utente/password di ClientLogin, AuthSub o OAuth.

Per ulteriori informazioni su AuthSub, OAuth e ClientLogin, consulta la panoramica sull'autenticazione delle API di dati di Google.

Suggerimento: l'API supporta SSL (HTTPS). Se utilizzi AuthSub/OAuth, assicurati di specificare un ambito https://sites.google.com/feeds/ per richiedere feed tramite SSL. Inoltre, per i domini G Suite, l'impostazione "Richiedi SSL" nel pannello di controllo amministrativo viene rispettata dall'API. Puoi forzare l'esecuzione di tutte le richieste API tramite HTTPS chiamando client.useSsl();.

AuthSub per le applicazioni web

L'autenticazione AuthSub per le applicazioni web deve essere utilizzata dalle applicazioni client che devono autenticare i propri utenti per gli Account Google. L'operatore non ha bisogno di accedere al nome utente e alla password dell'utente di Google Sites; è richiesto solo un token AuthSub.

Visualizza le istruzioni per incorporare AuthSub nella tua applicazione web

Richiedere un token monouso

Quando l'utente visita per la prima volta l'applicazione, deve eseguire l'autenticazione. In genere, gli sviluppatori stampano del testo e un link che indirizza l'utente alla pagina di approvazione di AuthSub per autenticare l'utente e richiedere l'accesso ai loro documenti. La libreria client Java di Google Data fornisce una funzione per generare questo URL. Il codice seguente consente di impostare un link alla pagina AuthSubRequest.

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

Se vuoi autenticare gli utenti sul tuo dominio ospitato da G Suite:

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

Il metodo getRequestUrl() richiede diversi parametri (corrispondenti ai parametri di query utilizzati dal gestore AuthSubRequest):

  • L'URL successivo, ovvero l'URL a cui Google reindirizzerà dopo che l'utente avrà eseguito l'accesso al proprio account e concesso l'accesso; http://www.example.com/welcome.jsp nell'esempio precedente
  • L'ambito: https://sites.google.com/feeds/ nell'esempio precedente
  • un valore booleano per indicare se il token verrà utilizzato in modalità registrata; false nell'esempio precedente
  • un secondo valore booleano per indicare se il token verrà successivamente scambiato con un token di sessione o meno; true nell'esempio precedente

Upgrade a un token di sessione

Consulta Utilizzo di AuthSub con le librerie client dell'API di dati di Google.

Recupero delle informazioni su un token di sessione

Consulta Utilizzo di AuthSub con le librerie client dell'API di dati di Google.

Revoca di un token di sessione

Consulta Utilizzo di AuthSub con le librerie client dell'API di dati di Google.

OAuth per applicazioni web o installate/mobile

Il protocollo OAuth può essere utilizzato in alternativa a AuthSub ed è destinato alle applicazioni web. OAuth è simile all'utilizzo della modalità protetta e registrata di AuthSub, in quanto tutte le richieste di dati devono essere firmate digitalmente e devi registrare il tuo dominio.

Visualizza le istruzioni per incorporare OAuth nell'applicazione installata

Recupero di un token di richiesta

Consulta Utilizzo di OAuth con le librerie client dell'API di dati di Google.

Autorizzazione di un token di richiesta

Consulta Utilizzo di OAuth con le librerie client dell'API di dati di Google.

Upgrade a un token di accesso

Consulta Utilizzo di OAuth con le librerie client dell'API di dati di Google.

ClientLogin per applicazioni installate/mobili

ClientLogin deve essere utilizzato da applicazioni installate o per dispositivi mobili che devono autenticare i propri utenti per gli Account Google. Alla prima esecuzione, l'applicazione richiede all'utente il nome utente e la password. Nelle richieste successive, viene fatto riferimento a un token di autenticazione.

Visualizza le istruzioni per incorporare ClientLogin nell'applicazione installata

Per utilizzare ClientLogin, richiama il metodo setUserCredentials() dell'oggetto SitesService, che viene ereditato da GoogleService. Specifica l'indirizzo email e la password dell'utente per conto del quale il tuo client effettua le richieste. Ad esempio:

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

Suggerimento: dopo che l'applicazione ha autenticato l'utente per la prima volta, archivia il token di autenticazione nel database per richiamarlo per un utilizzo futuro. Non è necessario richiedere all'utente la password a ogni esecuzione della tua applicazione. Per saperne di più, consulta Richiamo di un token di autenticazione.

Per ulteriori informazioni sull'uso di ClientLogin nelle applicazioni Java, consulta Utilizzo di ClientLogin con le librerie client dell'API di dati di Google.

Torna all'inizio

Feed sito

Il feed sito può essere utilizzato per elencare i siti Google di proprietà di un utente o per i quali dispone delle autorizzazioni di visualizzazione. Può essere utilizzato anche per modificare il nome di un sito esistente. Per i domini G Suite, può essere utilizzato anche per creare e/o copiare un intero sito.

Elenchi di siti

Per eseguire una query sul feed del sito, invia un GET HTTP all'URL del feed del sito:

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

Nel client Java, puoi utilizzare le classi SiteFeed e SiteEntry per lavorare con il feed del sito:

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

Lo snippet riportato sopra stampa il titolo, il nome e il tema del sito. Sono disponibili altri getter per accedere a proprietà aggiuntive nel feed.

Creare nuovi siti

Nota: questa funzionalità è disponibile solo per i domini G Suite.

È possibile eseguire il provisioning dei nuovi siti creando un nuovo SiteEntry e chiamando il metodo insert() del cliente nel feed del sito.

Questo esempio crea un nuovo sito con il tema "slate" (impostazione facoltativa) e fornisce il nome del sito (obbligatorio) e la descrizione (facoltativa):

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

La richiesta precedente creerà un nuovo sito nel dominio G Suite example.com. Pertanto, l'URL del sito sarà https://sites.google.com/a/example.com/my-site-title.

Se il sito è stato creato correttamente, il server risponderà con un oggetto SiteEntry, completato con gli elementi aggiunti dal server: un link al sito, un link al feed ACL del sito, il nome del sito, il titolo, il riepilogo e così via.

Copia di un sito

Nota: questa funzionalità è disponibile solo per i domini G Suite.

La procedura di copia di un sito è simile alla creazione di un nuovo sito. La differenza è che devi impostare un link sul tuo nuovo SiteEntry che includa il link autonomo del sito da duplicare. Di seguito è riportato un esempio di duplicazione del sito creato nella sezione Creazione di nuovi siti:

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

Punti importanti:

  • È possibile copiare solo i siti e i modelli di siti di proprietà dell'utente autenticato.
  • È possibile copiare anche un modello di sito. Un sito è un modello se l'impostazione "Pubblica questo sito come modello" è selezionata nella pagina delle impostazioni di Google Sites.
  • Puoi copiare un sito da un altro dominio, purché tu sia indicato come proprietario nel sito di origine.

Aggiornamento dei metadati di un sito

Per rinominare un sito, modificarne il tema, il tag di categoria o il riepilogo, devi prima recuperare il file SiteEntry contenente il sito in questione, modificare una o più proprietà e poi chiamare il metodo update() di SiteEntry. Questo esempio modifica il tema del sito precedente e rinomina il sito:

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

Mappature degli indirizzi web

Le mappature degli indirizzi web consentono agli utenti di Sites di mappare i propri domini a un sito Google. Ad esempio, può essere utilizzato http://www.mydomainsite.com al posto di http://sites.google.com/a/domain.com/mysite. A seconda di dove è ospitato il sito, puoi modificare manualmente le mappature degli indirizzi web di un sito. Per ulteriori informazioni, consulta l'articolo del Centro assistenza.

Recupero delle mappature degli indirizzi web di un sito

Per restituire le mappature degli indirizzi web di un sito, recupera la voce/feed del sito con il parametro 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());
  }
}

Le mappature esistenti verranno visualizzate come link con rel='webAddressMapping'. Ad esempio, nell'esempio precedente ci sono tre webAddressMapping che rimandano al sito http://sites.google.com/site/myOtherTestSite.

Modifica delle mappature degli indirizzi web

Nota: tutte le operazioni GET/POST/PUT devono specificare il parametro with-mappings=true quando si utilizzano le mappature di indirizzi web. Se il parametro non è presente, non verranno restituiti webAddressMapping nelle voci del sito (GET) o presi in considerazione durante l'aggiornamento/la rimozione (PUT) delle mappature da una voce.

Per aggiungere, aggiornare o eliminare una mappatura, specifica, modifica o rimuovi questo link durante la creazione di nuovi siti o l'aggiornamento dei metadati di un sito. Il parametro with-mappings=true deve essere incluso nell'URI del feed del sito. Nota: per aggiornare le mappature degli indirizzi, devi essere un amministratore di sito o un amministratore di dominio nel caso di un sito ospitato su G Suite.

Ad esempio, la richiesta riportata di seguito aggiorna il mapping di http://www.mysitemapping.com a http://www.my-new-sitemapping.com e rimuove http://www.mysitemapping2.com eliminando il link dalla voce:

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

Nota: le mappature degli indirizzi web possono essere specificate anche al momento della creazione/copia di un sito.

Torna all'inizio

Feed attività

Puoi recuperare l'attività recente di un sito (modifiche) recuperando il feed attività. Ogni voce nel feed delle attività contiene informazioni su una modifica apportata al sito.

Per eseguire una query sul feed attività, invia un GET HTTP all'URL del feed attività:

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

Nel client Java, utilizza la classe ActivityFeed per restituire gli oggetti 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());
  }
}

Nota: per accedere a questo feed devi essere un collaboratore o un proprietario del sito. Il client deve eseguire l'autenticazione utilizzando un token AuthSub, OAuth o ClientLogin. Vedi Autenticazione nel servizio Sites.

Torna all'inizio

Feed delle revisioni

Per recuperare la cronologia delle revisioni per qualsiasi voce di contenuti, invia un GET HTTP al link di revisione della voce:

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

Questo esempio esegue una query sul feed dei contenuti, quindi recupera il feed delle revisioni per la prima voce di contenuti:

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

Nota: per accedere a questo feed è necessario che tu sia un collaboratore o un proprietario del sito. Il client deve eseguire l'autenticazione utilizzando un token AuthSub, OAuth o ClientLogin. Vedi Autenticazione nel servizio Sites.

Torna all'inizio

Feed di contenuti

Recupero del feed di contenuti

Il feed di contenuti elenca i contenuti più recenti di un sito. È possibile accedervi inviando un GET HTTP all'URL del feed di contenuti:

https://sites.google.com/feeds/content/site/siteName
Parametro del feedDescrizione
site"site" o il dominio del tuo dominio ospitato da G Suite (ad es. example.com).
siteNameIl nome dello spazio web del tuo sito; indicato nell'URL del sito (ad es. mySite).

Esempio di recupero del feed di contenuti:

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

Il risultato contentFeed è un oggetto ContentFeed contenente la risposta dal server. Ogni voce di contentFeed rappresenta una pagina o un elemento diverso all'interno del sito dell'utente. ContentFeed conterrà diversi tipi di oggetti, tutti ereditati da BaseContentEntry: ListItemEntry, ListPageEntry, AttachmentEntry, WebAttachmentEntry, FileCabinetPageEntry, AnnouncementsPageEntry, AnnouncementEntry, WebPageEntry, CommentEntry.

Ecco un esempio di elenco dei diversi tipi di voci in un ContentFeed. Ogni tipo di voce contiene proprietà diverse, ma non tutte vengono stampate qui.

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

Nota: questo feed potrebbe richiedere o meno l'autenticazione, a seconda delle autorizzazioni di condivisione del sito. Se il sito non è pubblico, il client deve eseguire l'autenticazione utilizzando un token AuthSub, OAuth o ClientLogin. Vedi Autenticazione nel servizio Sites.

Esempi di query relative al feed di contenuti

Puoi cercare nel feed di contenuti alcuni parametri di query dell'API di dati di Google standard e quelli specifici dell'API della versione classica di Sites. Per informazioni più dettagliate e per un elenco completo dei parametri supportati, consulta la Guida di riferimento.

Nota: gli esempi in questa sezione utilizzano il metodo buildContentFeedUrl() nella sezione Recupero del feed di contenuti.

Recupero di tipi di voci specifici

Per recuperare solo un determinato tipo di voce, utilizza il parametro kind. Questo esempio restituisce solo attachment voci:

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

Per restituire più di un tipo di voce, separa ogni kind con una ",". In questo esempio vengono restituite le voci filecabinet e 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());
}

Recupero di una pagina in base al percorso

Se conosci il percorso relativo di una pagina all'interno del sito Google, puoi utilizzare il parametro path per recuperare quella pagina specifica. Questo esempio restituisce la pagina che si trova all'indirizzo 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());
}

Recupero di tutte le voci in una pagina padre

Se conosci l'ID voce dei contenuti di una pagina (ad es. "1234567890" nell'esempio di seguito), puoi utilizzare il parametro parent per recuperare tutte le relative voci figlio (se presenti):

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

Per ulteriori parametri, consulta la Guida di riferimento.

Torna all'inizio


Creazione di contenuti

Nota: prima di creare contenuti per un sito, assicurati di aver impostato il sito nel client.
client.site = "siteName";

Nuovi contenuti (pagine web, pagine elenco, pagine schedario, pagine di annunci e così via) possono essere creati inviando un POST HTTP al feed di contenuti:

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

Per un elenco dei tipi di nodi di assistenza, consulta il parametro kind nella Guida di riferimento.

Creare nuovi elementi / pagine

In questo esempio viene creato un nuovo webpage sotto il livello superiore del sito, viene incluso il codice ISBN per il corpo della pagina e il titolo dell'intestazione viene impostato su "Titolo nuova pagina web":

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

Se la richiesta ha esito positivo, createdEntry conterrà una copia della voce creata sul server.

Creazione di elementi/pagine in percorsi dell'URL personalizzati

Per impostazione predefinita, l'esempio precedente verrebbe creato nell'URL http://sites.google.com/site/siteName/new-webpage-title e avrà l'intestazione di pagina "Nuovo titolo pagina web". Questo significa che <atom:title> è normalizzato in new-webpage-title per l'URL. Per personalizzare il percorso dell'URL di una pagina, puoi impostare l'elemento <sites:pageName>.

In questo esempio viene creata una nuova pagina filecabinet con l'intestazione "File Storage", ma viene creata nell'URL http://sites.google.com/site/siteName/files (anziché http://sites.google.com/site/siteName/file-storage) specificando l'elemento <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());

Il server utilizza le seguenti regole di precedenza per la denominazione del percorso dell'URL di una pagina:

  1. <sites:pageName>, se presente. Deve soddisfare a-z, A-Z, 0-9, -, _.
  2. <atom:title>, non deve essere null se non è presente pageName. La normalizzazione consente di tagliare e comprimere lo spazio vuoto in "-" e di rimuovere i caratteri che non corrispondono a a-z, A-Z, 0-9, -, _.

Creazione di pagine secondarie

Per creare pagine secondarie (secondarie) in una pagina principale, devi impostare il link principale nella voce. Attributo href del link al link personale del nodo padre.

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

L'esempio riportato sopra crea un nuovo elemento announcement sotto la prima pagina di annunci trovata nel feed dei contenuti dell'utente. Il titolo dell'annuncio è impostato su "Festa!" e i contenuti su "Il mio posto, questo fine settimana".

Modelli di pagina

Creazione di modelli di pagina

Il processo per la creazione di un modello di pagina è la stessa della creazione di nuovi elementi/pagine e della creazione di pagine secondarie.La differenza è l'aggiunta di category con termine ed etichetta impostati rispettivamente su "http://schemas.google.com/g/2005#template" e "template".

In questo esempio viene creato un nuovo modello 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);

Creazione di pagine da un modello

Come per la creazione dei modelli di pagina, puoi creare un'istanza di una nuova pagina da un modello includendo un elemento <link> con rel='http://schemas.google.com/sites/2008#template' che rimandi al link personale di un modello di pagina.

Questo esempio crea un nuovo modello filecabinet e crea un'istanza di una nuova pagina filecabinet da quel modello.

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

Nota: nonostante un modello che definisce un <category>, è comunque obbligatorio includerne uno nel proprio inserimento. Tieni inoltre presente che se includi un elemento <content>, il server lo rifiuterà.

Caricamento di file

Proprio come in Google Sites, l'API supporta il caricamento degli allegati a una pagina Schedario o a una pagina principale.

Per caricare un allegato per un elemento principale, invia una richiesta HTTP POST all'URL del feed di contenuti:

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

Tutti i tipi di allegati devono essere caricati in una pagina padre. Pertanto, devi impostare un link principale nell'oggetto AttachmentEntry o WebAttachmentEntry che stai cercando di caricare. Per ulteriori informazioni, consulta la sezione Creazione di pagine secondarie.

Caricamento di allegati

In questo esempio viene caricato un file PDF nel primo FileCabinetPageEntry trovato nel feed dei contenuti dell'utente. L'allegato viene creato con il titolo "Guida introduttiva" e una descrizione (facoltativa), "Pacchetto 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!");

Se il caricamento ha esito positivo, attachment conterrà una copia della voce dell'allegato creata.

Caricamento di un allegato in una cartella

Per caricare un allegato in una cartella esistente in un file FileCabinetPageEntry, includi una categoria con l 'attributo "term" impostato sul nome della cartella. Ad esempio, aggiungi questa riga in uploadAttachment():

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

Allegati web

Gli allegati web sono tipi speciali di allegati. Essenzialmente, sono link ad altri file sul Web che puoi aggiungere alle tue schede dell'archivio. Questa funzione è analoga al metodo di caricamento "Aggiungi file tramite URL" nell'interfaccia utente di Google Sites.

Nota: gli allegati web possono essere creati solo in uno schedario. Non possono essere caricati in altri tipi di pagine.

In questo esempio viene creato un elemento WebAttachmentEntry sotto il primo FileCabinetPageEntry trovato nel feed dei contenuti dell'utente. Il titolo e la descrizione (facoltativa) sono impostati rispettivamente su "Logo Google" e "Belli colori".

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

L'POST crea un link nell'archivio dell'utente che indirizza all'immagine all'indirizzo "http://www.google.com/images/logo.gif".

Torna all'inizio


Aggiornamento dei contenuti

Aggiornamento dei metadati e/o dei contenuti html di una pagina

I metadati (titolo, pageName ecc.) e i contenuti della pagina di qualsiasi tipo BaseContentEntry possono essere modificati utilizzando il metodo update() della voce. Verrà inviata una richiesta HTTP PUT al link edit della voce.

Di seguito è riportato un esempio di aggiornamento di un ListPageEntry con le seguenti modifiche:

  • Il titolo viene modificato in "Titolo aggiornato"
  • I contenuti HTML della pagina vengono aggiornati in '<p>Contenuti HTML aggiornati</p>'
  • L'intestazione della prima colonna dell'elenco è stata modificata in "Proprietario"
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!");

Aggiornamento dei contenuti dei file allegati

Per AttachmentEntry, puoi anche aggiornare i contenuti impostando il valore MediaSource della voce e utilizzando il metodo updateMedia(boolean) della voce.

Questo esempio aggiornerà i contenuti di un allegato esistente:

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

L'esempio invia una richiesta PUT HTTP al link edit-media della voce. L'elemento AttachmentEntry restituito conterrà i contenuti aggiornati.

Aggiornare i metadati e i contenuti degli allegati

Puoi aggiornare i metadati e i contenuti di un allegato nella stessa chiamata utilizzando il metodo updateMedia(). Se puoi aggiornare solo i contenuti del file, i metadati o entrambi.

Questo esempio modifica il titolo dell'allegato in "Nuovo titolo", ne aggiorna la descrizione e sostituisce il contenuto del file con un nuovo file .zip. Poiché la richiesta include nuovi contenuti del file, viene utilizzato il updateMedia() di 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");

Torna all'inizio


Eliminazione dei contenuti

Per rimuovere una pagina o un elemento da un sito Google, recupera innanzitutto la voce di contenuto, quindi chiama delete() della voce.

entry.delete();

Puoi anche utilizzare il metodo delete() della classe di servizio trasferendo il link edit e il valore ETag della voce:

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

Se la voce è stata eliminata correttamente, il server risponde con un codice HTTP 200 OK.

Torna all'inizio


Download degli allegati

Per scaricare AttachmentEntry, invia una richiesta HTTP GET al link content src della voce.

Questo esempio scarica il primo AttachmentEntry trovato nel feed dei contenuti dell'utente nella directory "/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.");

Torna all'inizio

Feed ACL

Panoramica delle autorizzazioni di condivisione (ACL)

Ogni voce ACL nel feed ACL rappresenta un ruolo di accesso di una determinata entità: un utente, un gruppo di utenti, un dominio o l'accesso predefinito (ovvero un sito pubblico). Le voci verranno visualizzate solo per le entità con accesso esplicito: verrà mostrata una voce per ogni indirizzo email nel riquadro "Persone con accesso" della schermata di condivisione dell'interfaccia utente di Google Sites. Pertanto, gli amministratori di dominio non verranno mostrati, anche se hanno accesso implicito a un sito.

Ruoli

L'elemento ruolo rappresenta il livello di accesso che un'entità può avere. Esistono quattro valori possibili dell'elemento gAcl:role:

  • lettore: un visualizzatore (equivalente all'accesso di sola lettura).
  • writer: un collaboratore (equivalente all'accesso in lettura/scrittura).
  • owner: in genere l'amministratore del sito (equivalente all'accesso in lettura/scrittura).

Ambiti

L'elemento di ambito rappresenta l'entità che ha questo livello di accesso. Esistono quattro tipi possibili di elemento gAcl:scope:

  • utente: il valore di un indirizzo email, ad esempio "utente@gmail.com".
  • group: un indirizzo email di un gruppo Google, ad esempio "gruppo@dominio.com".
  • domain: un nome di dominio di G Suite, ad esempio "dominio.com".
  • default: esiste un solo ambito possibile di tipo "default", privo di valore (ad esempio <gAcl:scope type="default">). Questo ambito specifico controlla l'accesso di cui ogni utente dispone per impostazione predefinita su un sito pubblico.

Nota: i domini non possono avere un valore gAcl:role impostato sull'accesso "proprietario", ma possono essere solo lettori o scrittori.

Recupero del feed ACL

Le classi AclFeed e AclEntry possono essere utilizzate per controllare le autorizzazioni di condivisione di un sito e possono essere recuperate utilizzando il metodo getFeed() della classe di servizio.

L'esempio seguente recupera il feed ACL per un determinato sito e stampa le autorizzazioni di ogni 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');

Se stai utilizzando le voci del SiteFeed, ogni SiteEntry contiene un link al relativo feed ACL. Ad esempio, questo snippet recupera il feed acl di un SiteEntry:

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

Condividere un sito

Nota: alcuni ACL di condivisione potrebbero essere possibili solo se il dominio è configurato in modo da consentire queste autorizzazioni (ad esempio se è abilitata la condivisione all'esterno del dominio per i domini G Suite e così via).

Per condividere un sito Google utilizzando l'API, il client deve creare un nuovo elemento AclEntry e POST collegarlo al server.

Ecco un esempio in cui "utente@example.com" viene aggiunto come reader sul sito:

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

Consulta la sezione Panoramica del feed ACL per conoscere i possibili valori di AclScope e AclRoles.

Condivisione a livello di gruppo e di dominio

Analogamente alla condivisione di un sito con un singolo utente, puoi condividere un sito all'interno di un gruppo Google o di un dominio G Suite.

Condivisione con l'indirizzo email di un gruppo:

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

Condivisione con un intero dominio:

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

La condivisione a livello di dominio è supportata solo per i domini G Suite e solo per il dominio in cui è ospitato il sito. Ad esempio, http://sites.google.com/a/dominio1.com/sitoA può condividere l'intero sito solo con dominio1.com e non con dominio2.com. I siti che non sono ospitati su un dominio G Suite (ad es. http://sites.google.com/site/siteB) non possono invitare domini.

Modificare le autorizzazioni di condivisione

Per un'autorizzazione di condivisione esistente su un sito, recupera innanzitutto l'AclEntry in questione, modifica l'autorizzazione come preferisci, quindi chiama il metodo update() di AclEntry per modificare l'ACL sul server.

Questo esempio modifica l'esempio aclEntry precedente della sezione Condivisione di un sito, aggiornando "utente@example.com" in writer (collaboratore): 

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

Per ulteriori informazioni sugli ETag, consulta la guida di riferimento delle API di dati di Google.

Rimozione delle autorizzazioni di condivisione in corso...

Per rimuovere un'autorizzazione di condivisione, recupera prima il AclEntry, quindi chiama il relativo metodo delete():

aclEntry.delete();

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

Per ulteriori informazioni sugli ETag, consulta la guida di riferimento delle API di dati di Google.

Torna all'inizio

Argomenti speciali

Recuperare di nuovo un feed o una voce

Se vuoi recuperare un feed o una voce recuperati in precedenza, puoi migliorare l'efficienza comunicando al server di inviare l'elenco o la voce solo se sono cambiati dall'ultima volta che li hai recuperati.

Per eseguire questo tipo di recupero condizionale, entrambi i metodi getFeed() e getEntry() forniscono un argomento aggiuntivo che accetta un valore ETag o un oggetto DateTime per l'intestazione If-Modified-Since. Puoi accedere all'etag di una voce da entry.getEtag().

In questo esempio si esegue un recupero condizionale per una voce di una pagina web di contenuti:

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

Quando il server riceve questa richiesta, controlla se l'elemento richiesto abbia lo stesso ETag dell'ETag specificato. Se gli ETag corrispondono, l'elemento non è cambiato e il server restituisce un'eccezione HTTP 304 NotModifiedException.

Se gli ETag non corrispondono, significa che l'elemento è stato modificato dall'ultima richiesta e il server lo restituisce.

Per ulteriori informazioni sugli ETag, consulta la guida di riferimento delle API di dati di Google.

Torna all'inizio