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 ritirate ufficialmente a partire dal 20 aprile 2012 e non sono più disponibili. Ti invitiamo a eseguire la migrazione a 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 gli allegati.

Oltre a fornire alcune informazioni di base sulle funzionalità dell'API Sites Data, questa guida fornisce esempi di interazione con l'API utilizzando la libreria client Java. Per assistenza nella configurazione della libreria client, vedi Introduzione alla libreria client Java di Google Data. Se ti interessa saperne di più sul protocollo sottostante utilizzato dalla libreria client Java per interagire con l'API Sites classica, consulta la guida al protocollo.

Pubblico

Questo documento è destinato agli sviluppatori che vogliono scrivere applicazioni client che interagiscono con Google Sites utilizzando la libreria client Java di Google Data.

Per iniziare

Google Sites utilizza gli Account Google o gli 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 nella configurazione e nell'installazione della libreria client, consulta la pagina Guida introduttiva alla libreria client Java di Google Data. Se utilizzi Eclipse, l'articolo spiega anche come configurare il progetto utilizzando il plug-in Eclipse delle API Google Data. Ecco cosa ti serve per iniziare:

1. Installa Java 1.5 o versioni successive
2. Scarica la libreria client (l'ultima versione 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 i file .jar, dovrai includere quanto segue nel progetto:

1. java/lib/gdata-sites-2.0.jar - La versione 2.0 qui è pensata per la versione 1.4 dell'API Sites classica.
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 elenco / voci 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 completamente funzionante si trova nella sottodirectory /java/sample/sites del download di gdata-samples.java.zip. La sorgente è disponibile anche all'indirizzo /trunk/java/sample/sites/ nel repository SVN accessibile dalla scheda Sorgente. SitesDemo.java consente all'utente di eseguire una serie di operazioni che mostrano come utilizzare l'API Sites classica.

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

Avviare un progetto personale

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

A seconda delle esigenze della tua applicazione, dovrai eseguire 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 configurare anche un oggetto SitesService, che rappresenta una connessione client all'API Sites classica:

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

L'argomento applicationName deve seguire il formato company-applicationname-version. Questo parametro viene utilizzato a fini di registrazione.

Nota: il resto 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, a seconda delle autorizzazioni di Sites e dell'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 apportarvi aggiornamenti, operazione che richiederebbe un client autenticato. Questa operazione può essere eseguita tramite l'autenticazione con nome utente/password ClientLogin, AuthSub o OAuth.

Per saperne di più su AuthSub, OAuth e ClientLogin, consulta la Panoramica dell'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 i feed tramite SSL. Tieni presente inoltre 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 le applicazioni web

L'autenticazione AuthSub per 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/mobile

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 applicazioni installate/mobile

ClientLogin deve essere utilizzato da applicazioni installate o mobile che devono autenticare i propri utenti per gli Account Google. Al primo avvio, 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 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.

Siti di annunci

Per eseguire una query sul feed del sito, invia una richiesta HTTP GET 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 precedente stampa il titolo del sito, il nome del sito e il tema del sito. Sono disponibili altri getter per accedere ad altre proprietà nel feed.

Creare nuovi siti

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

I nuovi siti possono essere sottoposti a provisioning creando un nuovo SiteEntry e chiamando il metodo insert() del client 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 creerebbe 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 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.

Copiare un sito

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

La copia di un sito è simile alla creazione di un nuovo sito. La differenza è che devi impostare un link nel nuovo SiteEntry che includa il self-link del sito da duplicare. Ecco 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:

• Possono essere copiati 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 elencato come proprietario del 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 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, http://www.mydomainsite.com può essere utilizzato 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/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". Ad esempio, nell'esempio precedente sono presenti 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 lavora con i mapping degli indirizzi web. Se il parametro è assente, webAddressMappings non verrà restituito nelle voci del sito (GET) o preso in considerazione quando si aggiornano/rimuovono (PUT) i mapping da una voce.

Per aggiungere, aggiornare o eliminare un mapping, specifica, modifica o rimuovi un collegamento 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 del dominio nel caso di un sito ospitato da G Suite.

Ad esempio, la richiesta riportata di seguito aggiorna il mapping http://www.mysitemapping.com a http://www.my-new-sitemapping.com e rimuove http://www.mysitemapping2.com omettendo 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 i mapping degli indirizzi web possono essere specificati anche al momento della creazione/copia di un sito.

Torna all'inizio

Feed attività

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

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

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

Nel client Java, utilizza la classe ActivityFeed per restituire 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 il proprietario del sito. Il client deve autenticarsi utilizzando un token AuthSub, OAuth o ClientLogin. Consulta Autenticazione al servizio Sites.

Torna all'inizio

Feed delle revisioni

Per recuperare la cronologia delle revisioni di una voce di contenuti, invia una richiesta HTTP GET al link della revisione della voce:

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

Questo esempio esegue una query sul feed di contenuti e poi 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, devi essere un collaboratore o il proprietario del sito. Il client deve autenticarsi utilizzando un token AuthSub, OAuth o ClientLogin. Consulta Autenticazione al 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

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 contentFeed risultante è 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 cercare nel feed dei 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() in Recupero del feed di contenuti.

Recupero di tipi di voci specifici

Per recuperare solo un particolare 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 virgola (","). 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 per 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 restituirebbe 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 principale

Se conosci l'ID voce di contenuti di una pagina (ad es. "1234567890" nell'esempio riportato di seguito), 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

Creare contenuti

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

È possibile creare nuovi contenuti (pagine web, pagine elenco, pagine File Cabinet, pagine degli annunci e così via) inviando un comando HTTP POST 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 sotto il livello superiore del sito, include codice XHTML per il corpo della pagina e imposta il titolo dell'intestazione su "Nuovo titolo della 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 verrà creato nell'URL http://sites.google.com/site/siteName/new-webpage-title e avrà un titolo pagina "Nuovo titolo della pagina web". ovvero <atom:title> viene normalizzato a new-webpage-title per l'URL. Per personalizzare il percorso URL di una pagina, puoi impostare l'elemento <sites:pageName>.

Questo esempio crea una nuova pagina filecabinet con il titolo "Archiviazione file", ma crea la pagina 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 denominare il percorso URL di una pagina:

1. <sites:pageName>, se presente. Deve soddisfare a-z, A-Z, 0-9, -, _.
2. <atom:title>, non deve essere nullo se pageName non è presente. La normalizzazione consiste nel tagliare e comprimere gli spazi bianchi in "-" e rimuovere i caratteri che non corrispondono a a-z, A-Z, 0-9, -, _.

Creare pagine secondarie

Per creare pagine secondarie (figli) sotto una pagina principale, devi impostare il link principale nella voce. L'attributo href del link al link automatico 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 trovata nel feed di contenuti dell'utente. Il titolo dell'annuncio è impostato su "Festa!!" e i contenuti su "A casa mia, questo fine settimana".

Modelli di pagina

Creare modelli di pagina

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

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

Creare pagine da un modello

Analogamente alla creazione di modelli di pagina, puoi creare una nuova pagina da un modello includendo un <link> con rel='http://schemas.google.com/sites/2008#template' che rimanda al link automatico di un modello di pagina.

Questo esempio crea un nuovo modello filecabinet e poi crea un'istanza di una nuova pagina filecabinet da questo 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 presente inoltre che, se includi un elemento <content>, il server lo rifiuterà.

Caricamento di file

Come in Google Sites, l'API supporta il caricamento di 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 in una pagina principale. Pertanto, devi impostare un link principale sull'oggetto AttachmentEntry o WebAttachmentEntry che stai tentando di caricare. Per saperne di più, consulta Creazione di sottopagine.

Caricamento di allegati

Questo esempio carica 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 va a buon fine, attachment conterrà una copia della voce dell'allegato creato.

Caricare 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 ai tuoi annunci di armadietti. 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 un archivio. Non possono essere caricati su altri tipi di pagine.

Questo esempio crea un WebAttachmentEntry sotto il primo FileCabinetPageEntry trovato nel feed di contenuti dell'utente. Il titolo e la descrizione (facoltativa) sono impostati su "GoogleLogo" e "bei colori", rispettivamente.

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 punta 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 e così via) e i contenuti della pagina di qualsiasi tipo BaseContentEntry possono essere modificati utilizzando il metodo update() della voce. In questo modo, viene 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 a "<p>Updated HTML Content</p>".
• L'intestazione della prima 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 del file allegato

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

Questo esempio aggiornerà il contenuto 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 HTTP PUT al link edit-media della voce. Il file 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(). 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 contiene nuovi contenuti del file, viene utilizzato 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 prima la voce di contenuti, poi chiama delete() della voce.

entry.delete();

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

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 un AttachmentEntry, invia una richiesta HTTP GET al link src dei contenuti della voce.

Questo esempio scarica 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 (che è un sito pubblico). Le voci verranno mostrate solo per le entità con accesso esplicito. Verrà mostrata una voce per ogni indirizzo email nel riquadro "Persone con accesso" nella schermata di condivisione della UI di Google Sites. Pertanto, gli amministratori di dominio non verranno visualizzati, anche se hanno accesso implicito a un sito.

Ruoli

L'elemento ruolo rappresenta un 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).
• Scrittore: un collaboratore (equivalente all'accesso in lettura/scrittura).
• Proprietario: 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 di indirizzo email, ad esempio "user@gmail.com".
• group: un indirizzo email di Google Gruppi, ad esempio "group@domain.com".
• domain: un nome di dominio G Suite, ad esempio "domain.com".
• default: esiste un solo ambito possibile di tipo "default", che non ha alcun valore (ad es.<gAcl:scope type="default">). Questo ambito specifico controlla l'accesso che qualsiasi utente ha per impostazione predefinita su un sito pubblico.

Nota: i domini non possono avere un valore gAcl:role impostato su "Proprietario", ma solo su "Lettore" o "Autore".

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 lavori con le voci in SiteFeed, ogni SiteEntry contiene un link al proprio 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 per consentire tali autorizzazioni (ad es. se la condivisione all'esterno del dominio per i domini G Suite è abilitata e così via).

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

Ecco un esempio che aggiunge "user@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 di AclScope e AclRoles.

Condivisione a livello di gruppo e dominio

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

Condivisione con un indirizzo email del 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/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, quindi chiama il metodo update() di AclEntry per modificare la lista di controllo degli accessi sul server.

Questo esempio modifica il nostro precedente esempio aclEntry della sezione Condividere un sito, aggiornando "user@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 saperne di più sugli ETag, consulta la guida di riferimento delle API Google Data.

Rimozione delle autorizzazioni di condivisione

Per rimuovere un'autorizzazione di condivisione, recupera prima 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 saperne di più sugli ETag, consulta la guida di riferimento delle API 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 recuperato in precedenza, 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, sia il metodo getFeed() sia il metodo 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 per 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, verifica se l'elemento richiesto ha lo stesso ETag dell'ETag specificato. Se gli ETag corrispondono, l'elemento non è stato modificato e il server restituisce un'eccezione HTTP 304 NotModifiedException.

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

Per saperne di più sugli ETag, consulta la guida di riferimento delle API Google Data.

Torna all'inizio