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 ufficialmente ritirate dal 20 aprile 2012 e non sono più disponibili. Ti consigliamo di eseguire la migrazione ad OAuth 2.0 il prima 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. L'applicazione client può anche richiedere un elenco delle attività recenti, recuperare la cronologia delle revisioni e scaricare allegati.

Oltre a fornire alcune informazioni sulle funzionalità dell'API Sites Data, questa guida fornisce esempi per interagire con l'API utilizzando la libreria client Java. Per assistenza nella configurazione della libreria client, consulta Guida introduttiva alla libreria client Java di dati di Google. Se ti interessa approfondire il protocollo di base utilizzato dalla libreria client Java per interagire con l'API Sites classica, consulta la guida al protocollo.

Pubblico

Questo documento è rivolto agli sviluppatori che vogliono scrivere applicazioni client in grado di interagire con Google Sites utilizzando la libreria client Java di dati di Google.

Per iniziare

Google Sites utilizza Account Google o account G Suite per l'autenticazione. Se hai già un account, non devi fare altro. In caso contrario, puoi creare un nuovo account.

Installazione della libreria

Per assistenza con la configurazione e l'installazione della libreria client, consulta la pagina Introduzione alla libreria client Java Google Data. Se utilizzi Eclipse, nell'articolo viene spiegato anche come configurare il progetto utilizzando il plug-in Eclipse per le 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 (l'ultima versione di gdata-samples.java.zip)

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

1. java/lib/gdata-sites-2.0.jar: la versione 2.0 è 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 si utilizzano pagine di elenco/voci di elenco)

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

Esecuzione dell'applicazione di esempio

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

Tieni presente che dovrai includere java/sample/util/lib/sample-util.jar per eseguire il sample.

Iniziare un progetto

Suggerimento: consulta l'articolo Utilizzare 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, sono necessarie 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.*;

In seguito, 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 essere nel formato: company-applicationname-version. Questo parametro viene utilizzato per la registrazione.

Nota: il resto della guida presuppone che tu abbia creato un SitesService nella variabile client.

Autenticazione nella versione classica dell'API Sites

La libreria client Java può essere utilizzata per lavorare con feed pubblici o privati. L'API Sites Data fornisce l'accesso ai feed privati e pubblici, a seconda delle autorizzazioni di Sites e dell'operazione che stai tentando di eseguire. Ad esempio, potresti essere in grado di leggere il feed dei contenuti di un sito pubblico, ma non di aggiornarlo, un'operazione che richiede un client autenticato. Questo può essere fatto tramite autenticazione tramite nome utente/password 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 di https://sites.google.com/feeds/ per richiedere feed tramite SSL. Tieni inoltre presente che per i domini G Suite l'impostazione "Richiedi SSL" nel pannello di controllo amministrativo viene rispettata dall'API. Puoi forzare tutte le richieste API tramite HTTPS chiamando client.useSsl();.

AuthSub per applicazioni web

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

import com.google.gdata.client.*;

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

import com.google.gdata.client.*;

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

OAuth per applicazioni web o installate/per dispositivi mobili

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

ClientLogin per le applicazioni installate/mobile

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

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

Torna all'inizio

Feed sito

Il feed dei siti può essere utilizzato per elencare i siti Google di proprietà di un utente o per i quali ha 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.

Siti di schede

Per eseguire una query sul feed del sito, invia un messaggio 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 visualizza il titolo, il nome e il tema del sito. Sono disponibili altri getter per accedere a proprietà aggiuntive nel feed.

Creazione di nuovi siti

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

Per eseguire il provisioning dei nuovi siti, crea un nuovo SiteEntry e chiama il metodo insert() del cliente sul feed del sito.

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

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 crea 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 viene creato correttamente, il server risponderà con un oggetto SiteEntry, compilato con 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.

Copiare un sito

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

Copiare un sito è un'operazione simile alla creazione di un nuovo sito. La differenza è che devi impostare un link nel nuovo SiteEntry che includa il link autoreferenziale del sito da duplicare. Ecco un esempio di duplicazione del sito creato nella sezione Creare 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, a condizione che tu sia indicato come proprietario nel sito di origine.

Aggiornamento dei metadati di un sito

Per rinominare un sito, modificarne il tema, il tag categoria o il riepilogo, devi prima recuperare il 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 ne cambia il nome:

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, è possibile utilizzare http://www.mydomainsite.com al posto di http://sites.google.com/a/domain.com/mysite. A seconda di dove è ospitato il tuo sito, puoi modificare manualmente le mappature degli indirizzi web di un sito. Per saperne di più, consulta l'articolo del Centro assistenza.

Recuperare le mappature degli indirizzi web di un sito

Per restituire le mappature degli indirizzi web per un sito, recupera la voce o il 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'. Nell'esempio precedente, sono presenti tre webAddressMapping che puntano al sito http://sites.google.com/site/myOtherTestSite.

Modificare le mappature degli indirizzi web

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

Per aggiungere, aggiornare o eliminare una mappatura, specifica, modifica o rimuovi questo link quando crei nuovi siti o aggiorni i 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 del sito o un amministratore di dominio nel caso di un sito ospitato da G Suite.

Ad esempio, la richiesta riportata di seguito aggiorna la mappatura di http://www.mysitemapping.com a http://www.my-new-sitemapping.com e rimuove http://www.mysitemapping2.com escludendo 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();

Tieni presente che le mappature degli indirizzi web possono essere specificate anche al momento della creazione/copia di un sito.

Torna all'inizio

Feed attività

Puoi recuperare le attività recenti (modifiche) di un sito recuperando il feed delle attività. Ogni voce del feed delle attività contiene informazioni su una modifica apportata al sito.

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

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

Nel client Java, utilizza la classe ActivityFeed per restituire ActivityEntry oggetti:

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 il proprietario del sito. Il client deve autenticarsi utilizzando un token AuthSub, OAuth o ClientLogin. Consulta la sezione Autenticazione al servizio Sites.

Torna all'inizio

Feed delle revisioni

Per recuperare la cronologia delle revisioni di 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 e poi recupera il feed delle revisioni per la prima voce del feed dei 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 devi essere un collaboratore o il proprietario del sito. Il client deve autenticarsi utilizzando un token AuthSub, OAuth o ClientLogin. Consulta la sezione Autenticazione al servizio Sites.

Torna all'inizio

Feed di contenuti

Recupero del feed di contenuti in corso...

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

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 del 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 sono 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 autenticarsi utilizzando un token AuthSub, OAuth o ClientLogin. Consulta Autenticazione al servizio Sites.

Esempi di query del feed di contenuti

Puoi eseguire ricerche nel feed di contenuti utilizzando alcuni dei parametri di query standard dell'API Google Data e quelli specifici dell'API Sites classica. Per informazioni più dettagliate e un elenco completo dei parametri supportati, consulta la Guida di riferimento.

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

Recupero di tipi di voci specifici

Per recuperare solo un tipo specifico 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 un ",". Questo esempio restituisce 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());
}

Recuperare una pagina tramite percorso

Se conosci il percorso relativo di una pagina all'interno del sito Google, puoi utilizzare il parametro path per recuperare quella pagina specifica. In questo esempio viene restituita la pagina 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 principale

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

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

Per altri parametri, consulta la Guida di riferimento.

Torna all'inizio

Creazione di contenuti

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

È possibile creare nuovi contenuti (pagine web, pagine elenco, pagine armadietto, pagine di annunci e così via) inviando un POST HTTP al feed di contenuti:

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

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

Creazione di nuovi elementi / pagine

Questo esempio crea un nuovo webpage nel livello principale del sito, include del codice XHTML per il corpo della pagina e imposta il titolo della voce su "Nuovo titolo 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 URL personalizzati

Per impostazione predefinita, l'esempio precedente verrebbe creato nell'URL http://sites.google.com/site/siteName/new-webpage-title e avere un'intestazione di pagina "Nuovo titolo della pagina web". In altre parole, <atom:title> viene normalizzato in new-webpage-title per l'URL. Per personalizzare il percorso dell'URL di una pagina, puoi impostare l'elemento <sites:pageName>.

Questo esempio crea una nuova pagina filecabinet con l'intestazione "Archiviazione file", ma la crea con l'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 assegnare un nome al 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 pageName non è presente. La normalizzazione consiste nel tagliare e comprimere gli spazi vuoti in "-" e rimuovere i caratteri non corrispondenti a a-z, A-Z, 0-9, -, _.

Creazione di pagine secondarie

Per creare pagine secondarie (subordinate) in una pagina principale, devi impostare il link principale nella voce. L'attributo href del link al link autoreferenziale del nodo principale.

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 precedente crea un nuovo announcement nella prima pagina degli annunci presente nel feed di contenuti dell'utente. Il titolo dell'annuncio è impostato su "Festa!" e i contenuti su "La mia casa, questo fine settimana".

Modelli di pagina

Creazione di modelli di pagina

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

Questo esempio crea 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 di modelli di pagine, puoi creare una nuova pagina da un modello includendo un elemento <link> con rel='http://schemas.google.com/sites/2008#template' che rimandi al link autoreferenziale di un modello di pagina.

Questo esempio crea un nuovo modello filecabinet e poi esegue l'inizializzazione 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 definisca un <category>, è comunque necessario includerne uno nella voce. Tieni inoltre presente che, se includi un elemento <content>, il server lo rifiuterà.

Caricamento di file

Come in Google Sites, l'API supporta il caricamento degli allegati nella pagina dello schedario o in una pagina principale.

Per caricare un allegato a un genitore, invia una richiesta HTTP POST all'URL del feed dei contenuti:

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

Tutti i tipi di allegati devono essere caricati su una pagina principale. Pertanto, devi impostare un link principale sull'oggetto AttachmentEntry o WebAttachmentEntry che stai tentando 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 "Getting Started" e una descrizione (facoltativa), "HR package".

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 viene eseguito correttamente, attachment conterrà una copia della voce dell'allegato creato.

Caricamento di un allegato in una cartella

Per caricare un allegato in una cartella esistente in un 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. Si tratta essenzialmente di link ad altri file sul web che puoi aggiungere alle tue schede del cabinet di file. Questa funzionalità è analoga al metodo di caricamento "Aggiungi file tramite URL" nell'interfaccia utente di Google Sites.

Nota: gli allegati web possono essere creati solo in una raccolta. Non possono essere caricati su altri tipi di pagine.

In questo esempio viene creato un WebAttachmentEntry sotto il primo FileCabinetPageEntry trovato nel feed di contenuti dell'utente. Il titolo e la descrizione (facoltativa) sono impostati rispettivamente su "GoogleLogo" e "bei 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!");

POST crea un link nel filecabinet dell'utente che rimanda 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 (title, pageName e così via) e i contenuti della pagina di qualsiasi tipo di BaseContentEntry possono essere modificati utilizzando il metodo update() della voce. Verrà inviata una richiesta PUT HTTP 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>"
• La prima intestazione di colonna dell'elenco viene 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 quindi utilizzando il metodo updateMedia(boolean) della voce.

Questo esempio aggiorna 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.

Aggiornamento dei metadati e dei 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", aggiorna la descrizione e sostituisce i contenuti del file con un nuovo file ZIP. Poiché la richiesta contiene 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 di contenuti

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

entry.delete();

Puoi anche utilizzare il metodo delete() della classe di servizio passando 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, il server risponde con un 200 OK HTTP.

Torna all'inizio

Download degli allegati

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

In questo esempio viene scaricato il primo AttachmentEntry trovato nel feed di 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à, ovvero un utente, un gruppo di utenti, un dominio o l'accesso predefinito (ovvero un sito pubblico). Le voci verranno mostrate solo per le entità con accesso esplicito: verrà visualizzata una voce per ogni indirizzo email nel riquadro "Persone con accesso" nella schermata di condivisione dell'interfaccia utente di Google Sites. Pertanto, gli amministratori di dominio non verranno visualizzati, anche se hanno accesso implicito a un sito.

Ruoli

L'elemento Role rappresenta un livello di accesso che un'entità può avere. Esistono quattro valori possibili per l'elemento gAcl:role:

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

Ambiti

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

• user: un valore dell'indirizzo email, ad esempio "user@gmail.com".
• group: un indirizzo email di un gruppo Google, ad esempio "group@domain.com".
• domain: un nome di dominio G Suite, ad esempio "domain.com".
• default: esiste un solo possibile ambito di tipo "default", che non ha alcun valore (ad es.<gAcl:scope type="default">). Questo particolare ambito controlla l'accesso che ogni utente ha per impostazione predefinita su un sito pubblico.

Nota: i domini non possono avere un valore gAcl:role impostato su accesso "proprietario", ma solo su lettori o autori.

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 utilizzi le voci nel 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: alcune ACL di condivisione potrebbero essere possibili solo se il dominio è configurato per consentire queste autorizzazioni (ad es. se è attivata 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 AclEntry e POSTal server.

Ecco un esempio in cui viene aggiunto "utente@example.com" 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 i possibili valori AclScope e AclRoles.

Condivisione a livello di gruppo e dominio

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

Condivisione con un indirizzo email di 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 su cui è ospitato il sito. Ad esempio, http://sites.google.com/a/domain1.com/siteA può condividere l'intero sito solo con domain1.com, non con domain2.com. I siti che non sono ospitati su un dominio G Suite (ad es. http://sites.google.com/site/siteB) non possono invitare domini.

Modifica delle autorizzazioni di condivisione

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

Questo esempio modifica l'esempio aclEntry precedente della sezione Condividere un sito, aggiornando "utente@example.com" in modo che sia un 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 alle API di Google Data.

Rimozione delle autorizzazioni di condivisione

Per rimuovere un'autorizzazione di condivisione, recupera prima l'oggetto AclEntry e poi 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 alle API di Google Data.

Torna all'inizio

Argomenti speciali

Recuperare di nuovo un feed o una voce

Se vuoi recuperare un feed o una voce che hai già recuperato, puoi migliorare l'efficienza chiedendo al server di inviare l'elenco o la voce solo se è cambiato dall'ultima volta che l'hai recuperato.

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

Questo esempio esegue un recupero condizionale di una voce di 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 ha lo stesso ETag di quello specificato. Se gli ETag corrispondono, l'elemento non è stato modificato e il server restituisce un valore HTTP 304 NotModifiedException o viene lanciata un'eccezione.

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

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

Torna all'inizio