Il 22 novembre 2016 è stata lanciata una versione ricostruita di Sites. L'API Sites non può accedere ai siti creati con questa versione o modificarli, ma può comunque accedere alla versione classica di Sites.

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 Google Sites consente alle applicazioni client di accedere, pubblicare e modificare i contenuti all'interno di un sito di Google Sites. L'applicazione client può anche richiedere un elenco delle attività recenti, recuperare la cronologia delle revisioni e scaricare gli allegati.

Oltre a fornire 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 la Guida introduttiva alla libreria client Java di Google Data. Se ti interessa comprendere di più sul protocollo sottostante utilizzato dalla libreria client Java per interagire con l'API Sites, consulta la guida al protocollo.

Audience

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

Per cominciare

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

Installazione della raccolta

Per assistenza per la configurazione e l'installazione della libreria client, consulta la 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 di dati Google. 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 (la versione più recente di gdata-samples.java.zip)

Dopo aver installato .jars, devi includere i seguenti elementi nel tuo progetto:

  1. java/lib/gdata-sites-2.0.jar: la versione 2.0 è destinata alla versione 1.4 dell'API 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 utilizzi pagine / elementi elenco)

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

Esecuzione dell'applicazione di esempio

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

Tieni presente che dovrai includere java/sample/util/lib/sample-util.jar per eseguire l'esempio.

Iniziare il progetto

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

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

import com.google.gdata.client.*;
import com.google.gdata.client.sites.*;
import com.google.gdata.data.*;
import com.google.gdata.data.acl.*;
import com.google.gdata.data.media.*;
import com.google.gdata.data.sites.*;
import com.google.gdata.data.spreadsheet.*;  // If working with listpages / listitems
import com.google.gdata.util.*;

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

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

L'argomento applicationName deve seguire il formato: company-applicationname-version. Questo parametro viene utilizzato per scopi di logging.

Nota: nel resto di questa guida si presuppone che tu abbia creato un SitesService nella variabile client.

Autenticazione nell'API Sites

La libreria client Java può essere utilizzata per lavorare con feed pubblici o privati. L'API Sites Data fornisce 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 aggiornarlo, qualcosa che richiederebbe un client autenticato. Questa operazione può essere eseguita tramite l'autenticazione di nome utente e password ClientLogin, AuthSub o OAuth.

Per saperne di più 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 l'ambito https://sites.google.com/feeds/ per richiedere i feed su SSL. Tieni presente che, per i domini G Suite, l'impostazione 'Richiedi SSL' nel pannello di controllo amministrativo viene rispettata dall'API. Puoi forzare il trasferimento di tutte le richieste API su HTTPS chiamando il numero client.useSsl();.

AuthSub per applicazioni web

AuthSub Authentication for Web Applications deve essere utilizzato dalle applicazioni client che devono autenticare gli utenti negli Account Google. L'operatore non deve necessariamente accedere al nome utente e alla password dell'utente Google Sites: è richiesto solo un token AuthSub.

Visualizza le istruzioni per incorporare AuthSub nella tua applicazione web.

Richiedere un token monouso

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

import com.google.gdata.client.*;

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

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

import com.google.gdata.client.*;

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

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

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

Upgrade a un token di sessione

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

Recupero delle informazioni relative a un token di sessione

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

Revoca di un token di sessione

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

OAuth per applicazioni web o installate su dispositivi mobili

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

Visualizza le istruzioni per incorporare OAuth nell'applicazione installata

Recupero di un token di richiesta

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

Autorizzazione di un token di richiesta

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

Upgrade a un token di accesso

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

ClientLogin per le applicazioni installate/per dispositivi mobili

ClientLogin deve essere utilizzato da applicazioni installate o da dispositivi mobili che devono autenticare gli utenti agli Account Google. Alla prima esecuzione, la tua applicazione richiede all'utente il suo nome utente/la tua password. Per le richieste successive viene fatto riferimento a un token di autenticazione.

Visualizza le istruzioni per incorporare ClientLogin nella tua applicazione installata

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

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

Suggerimento: una volta che l'applicazione ha eseguito correttamente l'autenticazione dell'utente per la prima volta, memorizza il token di autenticazione nel database per utilizzarlo in seguito. Non è necessario richiedere all'utente la sua password a ogni esecuzione della tua applicazione. Per ulteriori informazioni, consulta l'articolo Richiamare un token di autenticazione.

Per ulteriori informazioni sull'utilizzo di ClientLogin nelle tue applicazioni Java, consulta l'articolo sull'utilizzo di ClientLogin con le librerie client dell'API di dati Google.

Torna all'inizio

Feed del sito

Il feed del sito può essere utilizzato per elencare i siti Google di proprietà di un utente o per cui si 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.

Elenco dei siti

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

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

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

public String getSiteFeedUrl() {
  String domain = "site";  // OR if the Site is hosted on G Suite, your domain (e.g. example.com)
  return "https://sites.google.com/feeds/site/" + domain + "/";
}

public void getSiteFeed() throws IOException, ServiceException {
  SiteFeed siteFeed = client.getFeed(new URL(getSiteFeedUrl()), SiteFeed.class);
  for (SiteEntry entry : siteFeed.getEntries()){
    System.out.println("title: " + entry.getTitle().getPlainText());
    System.out.println("site name: " + entry.getSiteName().getValue());
    System.out.println("theme: " + entry.getTheme().getValue());
    System.out.println("");
  }
}

Lo snippet riportato sopra stampa il titolo, il nome e il tema del sito. Sono disponibili altri token per l'accesso alle proprietà aggiuntive nel feed.

Creare nuovi siti

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

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

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

public String getSiteFeedUrl() {
  String domain = "example.com";
  return "https://sites.google.com/feeds/site/" + domain + "/";
}

public SiteEntry createSite(String title, String summary, String theme, String tag)
    throws MalformedURLException, IOException, ServiceException {
  SiteEntry entry = new SiteEntry();
  entry.setTitle(new PlainTextConstruct(title));
  entry.setSummary(new PlainTextConstruct(summary));

  Theme tt = new Theme();
  tt.setValue(theme);
  entry.setTheme(tt);

  entry.getCategories().add(new Category(TagCategory.Scheme.TAG, tag, null));

  return client.insert(new URL(getSiteFeedUrl()), entry);
}

SiteEntry newSiteEntry = createSite("My Site Title", "summary for site", "slate", "tag");

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

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

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 sul nuovo SiteEntry che includa il link autonomo 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:

  • È possibile copiare solo i siti e i modelli di sito di proprietà dell'utente autenticato.
  • Puoi anche copiare 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, in attesa di comparire come proprietario sul 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 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 di 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 sito, puoi modificare manualmente le mappature degli indirizzi web di un sito. Per ulteriori informazioni, consulta il nostro articolo del Centro assistenza.

Recupero di mappature di 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 relsql#39;webAddressMapping'. Ad esempio, nell'esempio sopra riportato 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 durante l'utilizzo delle mappature degli indirizzi web. Se il parametro non è presente, i parametri webAddressMapping non verranno restituiti nelle voci del sito (GET) né saranno presi in considerazione durante l'aggiornamento o la rimozione delle mappature da una voce.

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

Ad esempio, la richiesta qui sotto aggiorna la mappatura di http://www.mysitemapping.com a http://www.my-new-sitemapping.com e rimuove la 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 l'attività recente di un sito (modifiche) recuperando il feed delle attività. Ogni voce nel feed attività contiene informazioni su una modifica apportata al sito.

Per inviare una query sul feed di attività, invia un elemento GET HTTP all'URL del feed di 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 è necessario essere un collaboratore o un proprietario del sito. Il client deve eseguire l'autenticazione utilizzando un token AuthSub, OAuth o ClientLogin. Vedi Autenticazione al servizio Sites.

Torna all'inizio

Feed di revisione

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, quindi recupera il feed di revisione 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: l'accesso a questo feed richiede che tu sia un collaboratore o un proprietario del Sito. Il client deve eseguire l'autenticazione utilizzando un token AuthSub, OAuth o ClientLogin. Vedi Autenticazione 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. Per accedervi, invia un elemento GET HTTP all'URL del feed di contenuti:

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

Esempio di recupero del feed di contenuti:

public String buildContentFeedUrl() {
  String domain = "site";  // OR if the Site is hosted on G Suite, your domain (e.g. example.com)
  String siteName = "mySite";
  return "https://sites.google.com/feeds/content/" + domain + "/" + siteName + "/";
}

ContentFeed contentFeed = client.getFeed(new URL(buildContentFeedUrl()), ContentFeed.class);

L'oggetto 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à tipi diversi di oggetti, tutti ereditati da BaseContentEntry: ListItemEntry, ListPageEntry, AttachmentEntry, WebAttachmentEntry, FileCabinetPageEntry, AnnouncementsPageEntry, AnnouncementEntry, WebPageEntry, CommentEntry.

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

public String getContentBlob(BaseContentEntry<?> entry) {
 return ((XhtmlTextConstruct) entry.getTextContent().getContent()).getXhtml().getBlob();
}

// Extracts an entry's numeric ID.
private String getEntryId(String selfLink) {
  return selfLink.substring(selfLink.lastIndexOf("/") + 1);
}

public void printContentEntries(ContentFeed contentFeed) {
  System.out.println("Listing all WebPageEntry:");
  for (WebPageEntry entry : contentFeed.getEntries(WebPageEntry.class)) {
    System.out.println(" title: " + entry.getTitle().getPlainText());
    System.out.println(" id: " + getEntryId(entry));
    if (entry.getParentLink() != null) {
      System.out.println(" parent id: " + getEntryId(entry.getParentLink().getHref()));
    }
    System.out.println(" author: " + entry.getAuthors().get(0).getEmail());
    System.out.println(" content: " + getContentBlob(entry));
  }

  System.out.println("Listing all ListPageEntry:");
  for (ListPageEntry entry : contentFeed.getEntries(ListPageEntry.class)) {
    System.out.println(" title: " + entry.getTitle().getPlainText());
    System.out.println(" id: " + getEntryId(entry));
    for (Column col : entry.getData().getColumns()) {
      System.out.print(" [" + col.getIndex() + "] " + col.getName() + "\t");
    }
  }

  for (ListItemEntry entry : contentFeed.getEntries(ListItemEntry.class)) {
    for (Field field : entry.getFields()) {
      System.out.print(" [" + field.getIndex() + "] " + field.getValue() + "\t");
    }
    System.out.println("\n");
  }

  System.out.println("Listing all FileCabinetPageEntry:");
  for (FileCabinetPageEntry entry : contentFeed.getEntries(FileCabinetPageEntry.class)) {
    System.out.println(" title: " + entry.getTitle().getPlainText());
    System.out.println(" id: " + getEntryId(entry));
    System.out.println(" content: " + getContentBlob(entry));
  }

  System.out.println("Listing all CommentEntry:");
  for (CommentEntry entry : contentFeed.getEntries(CommentEntry.class)) {
    System.out.println(" in-reply-to: " + entry.getInReplyTo().toString());
    System.out.println(" content: " + getContentBlob(entry));
  }

  System.out.println("Listing all AnnouncementsPageEntry:");
  for (AnnouncementsPageEntry entry : contentFeed.getEntries(AnnouncementsPageEntry.class)) {
    System.out.println(" title: " + entry.getTitle().getPlainText());
    System.out.println(" id: " + getEntryId(entry));
    System.out.println(" content: " + getContentBlob(entry));
  }

  System.out.println("Listing all AnnouncementEntry:");
  for (AnnouncementEntry entry : contentFeed.getEntries(AnnouncementEntry.class)) {
    System.out.println(" title: " + entry.getTitle().getPlainText());
    System.out.println(" id: " + getEntryId(entry));
    if (entry.getParentLink() != null) {
      System.out.println(" parent id: " + getEntryId(entry.getParentLink().getHref()));
    }
    System.out.println(" draft?: " + entry.isDraft());
    System.out.println(" content: " + getContentBlob(entry));
  }

  System.out.println("Listing all AttachmentEntry:");
  for (AttachmentEntry entry : contentFeed.getEntries(AttachmentEntry.class)) {
    System.out.println(" title: " + entry.getTitle().getPlainText());
    System.out.println(" id: " + getEntryId(entry));
    if (entry.getParentLink() != null) {
      System.out.println(" parent id: " + getEntryId(entry.getParentLink().getHref()));
    }
    if (entry.getSummary() != null) {
      System.out.println(" description: " + entry.getSummary().getPlainText());
    }
    System.out.println(" revision: " + entry.getRevision().getValue());
    MediaContent content = (MediaContent) entry.getContent();
    System.out.println(" src: " + content.getUri());
    System.out.println(" content type: " + content.getMimeType().getMediaType());
  }

  System.out.println("Listing all WebAttachmentEntry:");
  for (WebAttachmentEntry entry : contentFeed.getEntries(WebAttachmentEntry.class)) {
    System.out.println(" title: " + entry.getTitle().getPlainText());
    System.out.println(" id: " + getEntryId(entry));
    if (entry.getParentLink() != null) {
      System.out.println(" parent id: " + getEntryId(entry.getParentLink().getHref()));
    }
    if (entry.getSummary() != null) {
      System.out.println(" description: " + entry.getSummary().getPlainText());
    }
    System.out.println(" src: " + ((MediaContent) entry.getContent()).getUri());
  }
}

Nota: questo feed può o meno richiedere l'autenticazione, in base alle autorizzazioni di condivisione del sito. Se il sito non è pubblico, il client deve eseguire l'autenticazione utilizzando un token AuthSub, OAuth o ClientLogin. Consulta la pagina relativa all'autenticazione al servizio Sites.

Esempi di query per i feed di contenuti

Puoi cercare nel feed dei contenuti utilizzando alcuni dei parametri standard delle query dell'API Google Data e quelli specifici dell'API Sites. 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() nel recupero del feed di contenuti.

Recupero di tipi di voci specifici

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

ContentQuery query = new ContentQuery(new URL(buildContentFeedUrl()));
query.setKind("webpage");
ContentFeed contentFeed = client.getFeed(query, ContentFeed.class);
for (AttachmentEntry entry : contentFeed.getEntries(AttachmentEntry.class)) {
  System.out.println(entry.getTitle().getPlainText());
}

Per restituire più di un tipo di voce, separa ogni kind con un ','. Questo esempio restituisce filecabinet e listpage voci:

URL url = new URL(buildContentFeedUrl() + "?kind=filecabinet,listpage");
ContentFeed contentFeed = client.getFeed(url, ContentFeed.class);
for (FileCabinetPageEntry entry : contentFeed.getEntries(FileCabinetPageEntry.class)) {
  System.out.println(" title: " + entry.getTitle().getPlainText());
}
for (ListPageEntry entry : contentFeed.getEntries(ListPageEntry.class)) {
  System.out.println(" title: " + entry.getTitle().getPlainText());
}

Recupero di una pagina tramite percorso

Se conosci il percorso relativo di una pagina nel sito di Google Sites, puoi utilizzare il parametro path per recuperarla. Questo esempio restituisce la pagina che si trova all'indirizzo http://sites.google.com/site/siteName/path/to/the/page:

ContentQuery query = new ContentQuery(new URL(buildContentFeedUrl()));
query.setPath("/path/to/the/page");
ContentFeed contentFeed = client.getFeed(query, ContentFeed.class);
for (BaseContentEntry<?> entry : contentFeed.getEntries()) {
  System.out.println(" title: " + entry.getTitle().getPlainText());
}

Recupero di tutte le voci di una pagina principale

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

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

Per ulteriori parametri, consulta la Guida di riferimento.

Torna all'inizio



Creare contenuti

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

Puoi creare nuovi contenuti (pagine web, pagine elenco, pagine Archivio, pagine di annunci e così via) inviando un elemento 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 al primo livello del sito, include parte del corpo della pagina XHTML e imposta il titolo dell'intestazione 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 verrà creato sotto l'URL http://sites.google.com/site/siteName/new-webpage-title e avrà l'intestazione di una pagina con 'Nuovo titolo della pagina web'. In altre parole, l'elemento <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>.

In questo esempio viene creata una nuova pagina filecabinet con l'intestazione 'File Storage', ma viene creata la pagina sotto 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 il a-z, A-Z, 0-9, -, _.
  2. <atom:title>, non deve essere null se pageName non è presente. La normalizzazione consiste nel tagliare e comprimere lo spazio vuoto in '-' e rimuovere i caratteri che non corrispondono a a-z, A-Z, 0-9, -, _.

Creare pagine secondarie

Per creare pagine secondarie (secondarie) in una pagina principale, devi impostare il link principale nella voce. L'attributo href del link all'autolink 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 sopra crea un nuovo announcement sotto la prima pagina di annunci trovata 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

Creare modelli di pagina

La procedura di creazione di un modello di pagina è uguale a quella di creazione di nuovi elementi/pagine e creazione di pagine secondarie. La differenza è l'aggiunta di category con il termine e l'etichetta impostati rispettivamente su 'http://schemas.google.com/g/2005#template' e 'template'.

In questo esempio viene creato un nuovo modello webpage.

// The template webpage entry.
WebPageEntry entry = new WebPageEntry();

// Set title and content.
entry.setTitle(new PlainTextConstruct("Page template title"));
XmlBlob xml = new XmlBlob();
xml.setBlob("Content for page template");
entry.setContent(new XhtmlTextConstruct(xml));

// Set the template category
Category TEMPLATE_CATEGORY = new Category(TemplateCategory.Scheme.LABELS,
    TemplateCategory.Term.TEMPLATE, TemplateCategory.Label.TEMPLATE);
entry.getCategories().add(TEMPLATE_CATEGORY);

// Insert the template webpage entry.
WebPageEntry createdEntry = client.insert(new URL("https://sites.google.com/feeds/content/site/siteName"), entry);

Creare pagine da un modello

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

In questo esempio viene creato un nuovo modello filecabinet e viene creata un'istanza di una nuova pagina filecabinet da quel modello.

URL feedUrl = new URL("https://sites.google.com/feeds/content/site/siteName");

// 1. Create file cabinet page template
FileCabinetPageEntry inputTemplateEntry = new FileCabinetPageEntry();
inputTemplateEntry.setTitle(new PlainTextConstruct("File cabinet page template title"));
XmlBlob xml = new XmlBlob();
xml.setBlob("Content for page template");
inputTemplateEntry.setContent(new XhtmlTextConstruct(xml));

// Set the template category
Category TEMPLATE_CATEGORY = new Category(TemplateCategory.Scheme.LABELS,
    TemplateCategory.Term.TEMPLATE, TemplateCategory.Label.TEMPLATE);
inputTemplateEntry.getCategories().add(TEMPLATE_CATEGORY);

// 2. Create file cabinet page template instance
FileCabinetPageEntry templateEntry = client.insert(feedUrl, inputTemplateEntry);

// Specify link to the page template
FileCabinetPageEntry templateInstanceEntry = new FileCabinetPageEntry();
templateInstanceEntry.setTitle(new PlainTextConstruct("File cabinet template instance"));
templateInstanceEntry.addLink(new Link(SitesLink.Rel.TEMPLATE, Link.Type.ATOM, templateEntry.getSelfLink().getHref()));

FileCabinetPageEntry createdFileCabinetFromTemplate =  client.insert(feedUrl, templateInstanceEntry);

Nota: nonostante un modello che definisca un elemento <category>, è ancora obbligatorio includerlo nella voce. Inoltre, tieni presente che se includi un elemento <content>, il server lo rifiuterà.

Caricamento di file

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

Per caricare un allegato in un file 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. Di conseguenza, imposti un link principale sull'oggetto AttachmentEntry o WebAttachmentEntry che stai tentando di caricare. Per ulteriori informazioni, consulta la sezione Creare pagine secondarie.

Caricamento di allegati

Questo esempio carica un file PDF nei primi FileCabinetPageEntry presenti nel feed di contenuti dell'utente. L'allegato viene creato con un titolo 'Getting Started' e una (facoltativa) descrizione, 'HR pacchetto'.

MimetypesFileTypeMap mediaTypes = new MimetypesFileTypeMap();
mediaTypes.addMimeTypes("application/msword doc");
mediaTypes.addMimeTypes("application/vnd.ms-excel xls");
mediaTypes.addMimeTypes("application/pdf pdf");
mediaTypes.addMimeTypes("text/richtext rtx");
// ... See a more complete list of mime types in the SitesHelper.java

public AttachmentEntry uploadAttachment(File file, BasePageEntry<?> parentPage,
    String title, String description) throws IOException, ServiceException {
  AttachmentEntry newAttachment = new AttachmentEntry();
  newAttachment.setMediaSource(new MediaFileSource(file, mediaTypes.getContentType(file)));
  newAttachment.setTitle(new PlainTextConstruct(title));
  newAttachment.setSummary(new PlainTextConstruct(description));
  newAttachment.addLink(SitesLink.Rel.PARENT, Link.Type.ATOM, parentPage.getSelfLink().getHref());

  return client.insert(new URL(buildContentFeedUrl()), newAttachment);
}

ContentFeed contentFeed = client.getFeed(new URL(buildContentFeedUrl() + "?kind=filecabinet"), ContentFeed.class);
FileCabinetPageEntry parentPage = contentFeed.getEntries(FileCabinetPageEntry.class).get(0);

AttachmentEntry attachment = uploadAttachment(
    new File("/path/to/your/file.pdf"), parentPage, "Getting Started", "HR packet");
System.out.println("Uploaded!");

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

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. Essenzialmente, sono link ad altri file sul Web che puoi aggiungere alle schede del tuo schedario. Questa funzionalità è analoga al metodo 'Aggiungi file tramite URL' metodo di caricamento nell'interfaccia utente di Google Sites.

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

Questo esempio crea un WebAttachmentEntry sotto i primi FileCabinetPageEntry trovati nel feed dei contenuti dell'utente. Il titolo e la descrizione (facoltativa) sono impostati rispettivamente su 'GoogleLogo' e 'nicecolor'.

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

Il POST crea un link nell'archivio dei file 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, pagina e così via) e i contenuti della pagina di qualsiasi tipo BaseContentEntry possono essere modificati utilizzando il metodo update() della voce. Verrà inviata una richiesta HTTP PUT al link edit della voce.

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

  • Il titolo è stato modificato in 'Title aggiornato'
  • I contenuti HTML della pagina vengono aggiornati a '<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 di un file allegato

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 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. L'elemento AttachmentEntry restituito conterrà il contenuto aggiornato.

Aggiornare i metadati e i contenuti degli allegati

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

Questo esempio cambia il titolo dell'allegato in "Nuovo titolo", ne aggiorna la descrizione e ne sostituisce i contenuti con un nuovo file .zip. Poiché la richiesta ha 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, devi prima recuperare la voce di contenuti e poi chiamare la voce delete().

entry.delete();

Puoi anche utilizzare il metodo delete() della classe di servizio passandogli 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 200 OK HTTP.

Torna all'inizio



Download degli allegati

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

Questo esempio scarica i primi AttachmentEntry trovati nel feed dei contenuti dell'utente nella directory "/path/to/save/file/":

private void downloadFile(String downloadUrl, String fullFilePath) throws IOException, ServiceException {
  System.out.println("Downloading file from: " + downloadUrl);

  MediaContent mc = new MediaContent();
  mc.setUri(downloadUrl);
  MediaSource ms = service.getMedia(mc);

  InputStream inStream = null;
  FileOutputStream outStream = null;

  try {
    inStream = ms.getInputStream();
    outStream = new FileOutputStream(fullFilePath);

    int c;
    while ((c = inStream.read()) != -1) {
      outStream.write(c);
    }
  } finally {
    if (inStream != null) {
      inStream.close();
    }
    if (outStream != null) {
      outStream.flush();
      outStream.close();
    }
  }
}

public void downloadAttachment(AttachmentEntry entry, String directory) throws IOException, ServiceException {
  String url = ((OutOfLineContent) entry.getContent()).getUri();
  downloadFile(url, directory + entry.getTitle().getPlainText()); // Use entry's title for the save filename
}

ContentFeed contentFeed = client.getFeed(
    new URL(buildContentFeedUrl() + "?kind=attachment&max-results=1"), ContentFeed.class);

downloadAttachment(contentFeed.getEntries(AttachmentEntry.class).get(0), "/path/to/save/file/");
System.out.println("Downloaded.");

Torna all'inizio

Feed ACL

Panoramica delle autorizzazioni di condivisione (ACL)

Ogni voce ACL nel feed ACL rappresenta un ruolo di accesso di una determinata entità, 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: una voce verrà mostrata 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 mostrati, anche se hanno accesso implicito a un sito.

Ruoli

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

  • reader: uno spettatore (equivalente a un accesso di sola lettura).
  • writer: un collaboratore (equivalente a accesso in lettura/scrittura).
  • owner: in genere l'amministratore del sito (equivalente a accesso in lettura/scrittura).

Mirini con ingrandimento

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

  • user: un valore dell'indirizzo email, ad esempio "utente@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 di tipo "default", che non ha alcun valore (ad esempio <gAcl:scope type="default">). Questo particolare ambito controlla l'accesso che ogni utente avrà per impostazione predefinita su un sito pubblico.

Nota: i domini non possono avere un valore gAcl:role impostato su "Proprietario", possono essere solo lettori o scrittori.

Recupero del feed ACL

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

L'esempio seguente recupera il feed ACL per un determinato sito e stampa le autorizzazioni di ogni AclEntry:

public String getAclFeedUrl(String siteName) {
  String domain = "site";  // OR if the Site is hosted on G Suite, your domain (e.g. example.com)
  return "https://sites.google.com/feeds/acl/site/" + domain + "/" + siteName + "/";
}

public void getAclFeed(String siteName) throws IOException, ServiceException {
  AclFeed aclFeed = client.getFeed(new URL(getAclFeedUrl(siteName)), AclFeed.class);
  for (AclEntry entry : aclFeed.getEntries()) {
    System.out.println(entry.getScope().getValue() + " (" + entry.getScope().getType() + ") : " +
                       entry.getRole().getValue());
  }
}

getAclFeed('my-site-name');

Se stai lavorando con 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: la condivisione di determinati ACL potrebbe essere possibile solo se il dominio è configurato per consentire queste autorizzazioni (ad esempio, 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 tuo client deve creare una nuova AclEntry e POST sul 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 AclScope e AclRoles.

Condivisione a livello di gruppo e dominio

Come per la condivisione di un sito con un singolo utente, puoi condividere un sito in un gruppo Google o 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/dominio1.com/sitoA può condividere solo l'intero sito con dominio1.com, non dominio2.com. I siti che non sono ospitati su un dominio G Suite (ad esempio http://sites.google.com/sito/sitoB) non possono invitare i domini.

Modifica delle autorizzazioni di condivisione

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

Questo esempio modifica il nostro esempio aclEntry precedente dalla sezione Condivisione di un sito, aggiornando 'user@example.com' per essere 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 delle API di dati di Google.

Rimozione delle autorizzazioni di condivisione

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

aclEntry.delete();

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

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

Torna all'inizio

Argomenti speciali

Recupero di un feed o di una nuova voce

Se vuoi recuperare un feed o una voce che hai recuperato in precedenza, puoi migliorare l'efficienza comunicando al server di inviare l'elenco o la voce solo se è cambiata dall'ultima volta che l'hai recuperata.

Per fare 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 alla voce di una voce da entry.getEtag().

Questo esempio esegue un recupero condizionale per una voce di pagina web dei 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 dell'ETag specificato. Se la corrispondenza ETag, l'elemento non è cambiato e il server restituisce un'eccezione HTTP 304 NotModifiedException.

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

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

Torna all'inizio