Importante: questo documento è stato scritto prima del 2012. Opzioni di autenticazione descritte in questo documento (OAuth 1.0, AuthSub e ClientLogin) sono state ufficialmente ritirato dal 20 aprile 2012 e non sono più disponibili. Ti invitiamo a eseguire la migrazione OAuth 2.0, il prima possibile.
L'API di dati di Google Sites consente alle applicazioni client di accedere, pubblicare e modificare i contenuti all'interno di un sito Google. L'applicazione client può anche richiedere un elenco delle attività recenti, recuperare la cronologia delle revisioni e scaricare allegati.
Oltre a fornire alcune informazioni sulle funzionalità dell'API Sites Data, questa guida fornisce esempi di interazione con l'API. utilizzando la libreria client Java. Per informazioni sulla configurazione della libreria client, consulta Introduzione alla libreria client Java di dati di Google. Se ti interessa per maggiori informazioni sul protocollo sottostante utilizzato dalla libreria client Java per interagire con l'API della versione classica di Sites, consulta il guida al protocollo.
Pubblico
Questo documento è rivolto agli sviluppatori che desiderano scrivere applicazioni client che interagiscano con Google Sites. utilizzando la libreria client Java di dati di Google.
Per iniziare
Google Sites utilizza Account Google o account G Suite per l'autenticazione. Se hai già un account, non devi fare altro. In alternativa, puoi creare un nuovo account.
Installazione della libreria
Per assistenza nella configurazione e nell'installazione della libreria client, consulta la guida introduttiva alla libreria client Java dei dati di Google. Se usi Eclipse, questo articolo spiega anche come configurare il progetto utilizzando il plug-in Eclipse delle API di dati di Google. Ecco cosa ti serve per iniziare:
- Installa Java 1.5 o versioni successive
- Scarica la libreria client (la versione più recente di
gdata-src.java.zip
) - Scarica l'elenco delle dipendenze
- Scarica le applicazioni di esempio (l'ultima versione di
gdata-samples.java.zip
)
Dopo aver installato il file .jars, dovrai includere quanto segue nel tuo progetto:
java/lib/gdata-sites-2.0.jar
: la versione 2.0 è destinata alla versione 1.4 dell'API della versione classica di Sites.java/lib/gdata-core-1.0.jar
java/lib/gdata-client-1.0.jar
java/lib/gdata-spreadsheet-3.0.jar
(se utilizzi pagine elenco / elementi di elenco)
Inoltre, assicurati di includere i jar delle dipendenze (gdata-media-1.0.jar
, mail.jar
e google-collect....jar
).
Esecuzione dell'applicazione di esempio
Un'applicazione di esempio funzionante completa si trova nella sottodirectory /java/sample/sites
del download di gdata-samples.java.zip
.
Il codice sorgente è 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 dimostrano come utilizzare l'API della versione classica di Sites.
Tieni presente che dovrai includere java/sample/util/lib/sample-util.jar
per eseguire l'esempio.
Iniziare un progetto
Suggerimento: consulta l'articolo Utilizzare Eclipse con le API di dati di Google per una rapida configurazione con il plug-in Eclipse.
A seconda delle esigenze della tua applicazione, avrai bisogno di diverse importazioni. Ti consigliamo di iniziare con le seguenti importazioni:
import com.google.gdata.client.*; import com.google.gdata.client.sites.*; import com.google.gdata.data.*; import com.google.gdata.data.acl.*; import com.google.gdata.data.media.*; import com.google.gdata.data.sites.*; import com.google.gdata.data.spreadsheet.*; // If working with listpages / listitems import com.google.gdata.util.*;
In seguito, dovrai anche configurare un oggetto SitesService
, che rappresenta una connessione client all'API della versione classica di Sites:
SitesService client = new SitesService("yourCo-yourAppName-v1");
L'argomento applicationName
deve essere nel formato: company-applicationname-version
. Questo parametro viene utilizzato per la registrazione.
Nota: il resto della guida presuppone che tu abbia creato un SitesService
nella variabile client
.
Autenticazione nella versione classica dell'API Sites
La libreria client Java può essere utilizzata per lavorare con feed pubblici o privati. L'API Sites Data fornisce l'accesso a siti privati e pubblici feed, in base alle autorizzazioni di Sites e all'operazione che stai tentando di eseguire. Ad esempio, potresti riuscire a leggere il feed di contenuti di un sito pubblico senza però aggiornarlo, cosa che richiederebbe un client autenticato. Questa operazione può essere eseguita tramite Autenticazione nome utente/password di ClientLogin, AuthSub o OAuth.
Per ulteriori informazioni su AuthSub, OAuth e ClientLogin, consulta la panoramica sull'autenticazione delle API di dati di Google.
Suggerimento: l'API supporta SSL (HTTPS). Se utilizzi AuthSub/OAuth, assicurati di specificare
un ambito di https://sites.google.com/feeds/
per richiedere feed tramite SSL. Inoltre, tieni presente che
Domini G Suite, la sezione "Richiedi SSL" nel pannello di controllo amministrativo viene rispettata dall'API. Puoi forzare tutti
Le richieste API devono essere tramite HTTPS chiamando client.useSsl();
.
AuthSub per applicazioni web
L'autenticazione AuthSub per le applicazioni web dovrebbe essere utilizzata dalle applicazioni client che devono autenticare i propri utenti agli Account Google. L'operatore non ha bisogno di accedere al nome utente e alla password dell'utente di Google Sites, ma solo un Il token AuthSub è obbligatorio.
Visualizza le istruzioni per incorporare AuthSub nella tua applicazione web
Richiedi un token monouso
Quando l'utente visita per la prima volta la tua applicazione, deve eseguire l'autenticazione. In genere, gli sviluppatori stampano del testo e un link che indirizza l'utente alla pagina di approvazione 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 tuo dominio ospitato da G Suite:
import com.google.gdata.client.*; String hostedDomain = "example.com"; String nextUrl = "http://www.example.com/welcome.jsp"; String scope = "https://sites.google.com/feeds/"; // SSL is also supported boolean secure = true; boolean session = true; String authSubUrl = AuthSubUtil.getRequestUrl(hostedDomain, nextUrl, scope, secure, session);
Il metodo getRequestUrl()
richiede diversi parametri (corrispondenti ai parametri di query utilizzati dal gestore AuthSubRequest):
- L'URL successivo, a cui Google reindirizzerà
dopo che l'utente accede al proprio account e concede l'accesso;
http://www.example.com/welcome.jsp
nell'esempio precedente - scope:
https://sites.google.com/feeds/
nell'esempio precedente - Un valore booleano per indicare se il token verrà utilizzato o meno in modalità registrata.
false
nell'esempio precedente - un secondo booleano per indicare se in un secondo momento il token verrà scambiato con un token di sessione o meno;
true
nell'esempio precedente
Upgrade a un token di sessione
Consulta Utilizzo di AuthSub con le librerie client dell'API di dati di Google.
Recupero di informazioni su un token di sessione
Consulta Utilizzo di AuthSub con le librerie client dell'API di dati di Google.
Revoca di un token di sessione
Consulta Utilizzo di AuthSub con le librerie client dell'API di dati di Google.
OAuth per applicazioni web o installate/per dispositivi mobili
OAuth può essere utilizzato in alternativa ad AuthSub ed è destinato alle applicazioni web. OAuth è un processo simile all'utilizzo della modalità sicura e registrata di AuthSub. tutte le richieste di dati devono essere firmate digitalmente e devi registrare il dominio.
Visualizza le istruzioni per incorporare OAuth nell'applicazione installata
Recupero di un token di richiesta
Consulta l'articolo Utilizzare OAuth con le librerie client dell'API di dati di Google.
Autorizzazione di un token di richiesta
Consulta l'articolo Utilizzare OAuth con le librerie client dell'API di dati di Google.
Upgrade a un token di accesso
Consulta l'articolo Utilizzare OAuth con le librerie client dell'API di dati di Google.
ClientLogin per applicazioni installate/mobile
ClientLogin deve essere utilizzato da applicazioni installate o per dispositivi mobili che devono autenticare i propri utenti agli Account Google. Alla prima esecuzione, l'applicazione richiede all'utente il nome utente e la password. Per le richieste successive, viene fatto riferimento a un token di autenticazione.
Visualizza le istruzioni per incorporare ClientLogin nell'applicazione installata
Per utilizzare ClientLogin, richiama il metodo
setUserCredentials()
:
dell'oggetto SitesService
, che viene ereditato
GoogleService
Specifica l'indirizzo email e la password dell'utente
per conto di cui il cliente effettua le richieste. Ad esempio:
SitesService client = new SitesService("yourCo-yourAppName-v1"); client.setUserCredentials("example@gmail.com", "pa$$word");
Suggerimento: dopo che l'applicazione ha autenticato l'utente per la prima volta, memorizza il token di autenticazione nel da richiamare per utilizzarlo in un secondo momento. Non è necessario richiedere all'utente la password a ogni esecuzione dell'applicazione. Per ulteriori informazioni, consulta la sezione Richiamo di un token di autenticazione.
Per ulteriori informazioni sull'utilizzo di ClientLogin nelle applicazioni Java, consulta Utilizzo di ClientLogin con le librerie client dell'API di dati di Google.
Feed sito
Il feed del sito può essere utilizzato per elencare i siti di Google Sites 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 l'intero sito.
Siti delle schede
Per eseguire una query sul feed del sito, invia un messaggio GET
HTTP all'URL del feed del sito:
https://sites.google.com/feeds/site/site/
Nel client Java, puoi utilizzare le classi SiteFeed
e SiteEntry
per lavorare
con il feed del sito:
public String getSiteFeedUrl() { String domain = "site"; // OR if the Site is hosted on G Suite, your domain (e.g. example.com) return "https://sites.google.com/feeds/site/" + domain + "/"; } public void getSiteFeed() throws IOException, ServiceException { SiteFeed siteFeed = client.getFeed(new URL(getSiteFeedUrl()), SiteFeed.class); for (SiteEntry entry : siteFeed.getEntries()){ System.out.println("title: " + entry.getTitle().getPlainText()); System.out.println("site name: " + entry.getSiteName().getValue()); System.out.println("theme: " + entry.getTheme().getValue()); System.out.println(""); } }
Lo snippet precedente stampa il titolo, il nome e il tema del sito. Sono disponibili altri getter accedere ad altre proprietà nel feed.
Creazione di nuovi siti
Nota: questa funzionalità è disponibile solo per i domini G Suite.
Per eseguire il provisioning dei nuovi siti, puoi creare un nuovo SiteEntry
e chiamare il nome del client
insert()
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 crea un nuovo sito nel dominio G Suite example.com
.
Pertanto, l'URL del sito sarà https://sites.google.com/a/example.com/my-site-title.
Se il sito viene creato correttamente, il server risponderà con SiteEntry
con gli elementi aggiunti dal server: un link al sito, un link al feed ACL del sito,
il nome del sito, il titolo, il riepilogo e così via.
Copia di un sito
Nota: questa funzionalità è disponibile solo per i domini G Suite.
Copiare un sito è un'operazione simile alla creazione di un nuovo sito. La differenza è che devi impostare
sul nuovo SiteEntry
che include il link stesso 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:
- Puoi copiare solo i siti e i modelli di siti di proprietà dell'utente autenticato.
- Puoi anche copiare un modello di sito. Un sito è un modello se l'opzione "Pubblica questo sito come modello" sia selezionata nella pagina delle impostazioni di Google Sites.
- Puoi copiare un sito da un altro dominio, a condizione che tu sia indicato come proprietario nel sito di origine.
Aggiornamento dei metadati di un sito
Per rinominare un sito, cambiarne il tema, il tag di categoria o il riepilogo, devi prima recuperare SiteEntry
contenente il sito in questione,
modificare una o più proprietà, quindi 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 un
mappature degli indirizzi web del sito. Per saperne di più, consulta l'articolo del Centro assistenza.
Recupero delle mappature degli indirizzi web di un sito
Per restituire le mappature degli indirizzi web per un sito, recupera la voce o il feed del sito con il parametro with-mappings=true
:
SiteQuery query = new SiteQuery(new URL("https://sites.google.com/feeds/site/siteName")); query.setWithMappings(true); SiteFeed feed = service.getFeed(query, SiteFeed.class); for (SiteEntry entry : feed.getEntries()) { System.out.println("Mappings for '" + entry.getSiteName().getValue() + "':"); for (Link link : entry.getWebAddressMappingLinks()) { System.out.println(" " + link.getHref()); } }
Le mappature esistenti verranno visualizzate come link
con rel='webAddressMapping'. Nell'esempio riportato sopra,
ci sono tre webAddressMapping
che puntano 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 le mappature degli indirizzi web. Se il parametro non è presente, webAddressMapping
non verranno restituiti nelle voci del sito (GET) né considerati
durante l'aggiornamento/la rimozione delle mappature (PUT) da una voce.
Per aggiungere, aggiornare o eliminare una mappatura, è sufficiente specificare, modificare o rimuovere questo link durante la creazione di nuovi siti oppure
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 del sito o un amministratore di dominio nel caso di un sito ospitato da G Suite.
Ad esempio, la richiesta seguente aggiorna la mappatura http://www.mysitemapping.com
a http://www.my-new-sitemapping.com
,
e rimuove http://www.mysitemapping2.com
lasciando il link fuori dalla voce:
SiteEntry entry = client.getEntry(new URL("https://sites.google.com/feeds/site/site/siteName?with-mappings=true"), SiteEntry.class); // Modify mappings (remove all mappings, add some of them again, add modified mappings) entry.removeLinks(SitesLink.Rel.WEBADDRESSMAPPING, Link.Type.HTML); entry.addLink(SitesLink.Rel.WEBADDRESSMAPPING, Link.Type.HTML, "http://www.my-new-sitemapping.com"); // Update the entry with the mappings. entry.update();
Nota: le mappature degli indirizzi web possono essere specificate anche in fase di creazione/copia di un sito.
Feed attività
Puoi recuperare l'attività recente (modifiche) di un sito recuperando il feed attività. Ogni voce nel il feed attività contiene informazioni su una modifica apportata al Sito.
Per eseguire una query sul feed attività, invia un messaggio GET
HTTP all'URL del feed attività:
https://sites.google.com/feeds/activity/site/siteName
Nel client Java, utilizza la classe ActivityFeed
per restituire ActivityEntry
oggetti:
public String buildActivityFeedUrl() { String domain = "site"; // OR if the Site is hosted on G Suite, your domain (e.g. example.com) String siteName = "mySite"; return "https://sites.google.com/feeds/activity/" + domain + "/" + siteName + "/"; } public void getActivityFeed() throws IOException, ServiceException { ActivityFeed activityFeed = client.getFeed(new URL(buildActivityFeedUrl()), ActivityFeed.class); for (BaseActivityEntry<?> entry : activityFeed.getEntries()){ System.out.println(entry.getSummary().getPlainText()); System.out.println(" revisions link: " + entry.getRevisionLink().getHref()); } }
Nota: per accedere a questo feed è necessario essere un collaboratore o un proprietario del sito. Il client deve eseguire l'autenticazione utilizzando un token AuthSub, OAuth o ClientLogin. Consulta Autenticazione nel servizio Sites.
Feed delle revisioni
Per recuperare la cronologia delle revisioni per qualsiasi voce di contenuto, invia un GET
HTTP al link di revisione della voce:
https://sites.google.com/feeds/revision/site/siteName/CONTENT_ENTRY_ID
In questo esempio viene eseguita una query sul feed di contenuti, quindi recupera il feed delle revisioni per la prima voce di contenuti:
ContentFeed contentFeed = client.getFeed(new URL(buildContentFeedUrl()), ContentFeed.class); URL revisionFeedUrl = new URL(contentFeed.getEntries().get(0).getRevisionLink().getHref()); // use first entry public void getRevisionFeed(String revisionFeedUrl) throws IOException, ServiceException { RevisionFeed revisionFeed = client.getFeed(revisionFeedUrl, RevisionFeed.class); for (BaseContentEntry<?> entry : revisionFeed.getEntries()){ System.out.println(entry.getTitle().getPlainText()); System.out.println(" updated: " + entry.getUpdated().toUiString() + " by " + entry.getAuthors().get(0).getEmail()); System.out.println(" revision #: " + entry.getRevision().getValue()); } }
Nota: per accedere a questo feed è necessario essere un collaboratore o un proprietario del sito. Il client deve eseguire l'autenticazione utilizzando un token AuthSub, OAuth o ClientLogin. Consulta Autenticazione nel servizio Sites.
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 GET
HTTP all'URL del feed di contenuti:
https://sites.google.com/feeds/content/site/siteName
Parametro feed | Descrizione |
---|---|
site | "site " o il dominio del tuo dominio ospitato da G Suite (ad es. example.com ). |
siteName | Il nome dello spazio web del tuo sito; presente nell'URL del Sito (ad es. mySite ). |
Esempio di recupero del feed di contenuti:
public String buildContentFeedUrl() { String domain = "site"; // OR if the Site is hosted on G Suite, your domain (e.g. example.com) String siteName = "mySite"; return "https://sites.google.com/feeds/content/" + domain + "/" + siteName + "/"; } ContentFeed contentFeed = client.getFeed(new URL(buildContentFeedUrl()), ContentFeed.class);
Il risultato contentFeed
è un oggetto ContentFeed
contenente la risposta 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
e CommentEntry
.
Ecco un esempio di elenco dei diversi tipi di voci in un ContentFeed
.
Ogni tipo di voce contiene proprietà diverse, ma non tutte vengono stampate qui.
public String getContentBlob(BaseContentEntry<?> entry) { return ((XhtmlTextConstruct) entry.getTextContent().getContent()).getXhtml().getBlob(); } // Extracts an entry's numeric ID. private String getEntryId(String selfLink) { return selfLink.substring(selfLink.lastIndexOf("/") + 1); } public void printContentEntries(ContentFeed contentFeed) { System.out.println("Listing all WebPageEntry:"); for (WebPageEntry entry : contentFeed.getEntries(WebPageEntry.class)) { System.out.println(" title: " + entry.getTitle().getPlainText()); System.out.println(" id: " + getEntryId(entry)); if (entry.getParentLink() != null) { System.out.println(" parent id: " + getEntryId(entry.getParentLink().getHref())); } System.out.println(" author: " + entry.getAuthors().get(0).getEmail()); System.out.println(" content: " + getContentBlob(entry)); } System.out.println("Listing all ListPageEntry:"); for (ListPageEntry entry : contentFeed.getEntries(ListPageEntry.class)) { System.out.println(" title: " + entry.getTitle().getPlainText()); System.out.println(" id: " + getEntryId(entry)); for (Column col : entry.getData().getColumns()) { System.out.print(" [" + col.getIndex() + "] " + col.getName() + "\t"); } } for (ListItemEntry entry : contentFeed.getEntries(ListItemEntry.class)) { for (Field field : entry.getFields()) { System.out.print(" [" + field.getIndex() + "] " + field.getValue() + "\t"); } System.out.println("\n"); } System.out.println("Listing all FileCabinetPageEntry:"); for (FileCabinetPageEntry entry : contentFeed.getEntries(FileCabinetPageEntry.class)) { System.out.println(" title: " + entry.getTitle().getPlainText()); System.out.println(" id: " + getEntryId(entry)); System.out.println(" content: " + getContentBlob(entry)); } System.out.println("Listing all CommentEntry:"); for (CommentEntry entry : contentFeed.getEntries(CommentEntry.class)) { System.out.println(" in-reply-to: " + entry.getInReplyTo().toString()); System.out.println(" content: " + getContentBlob(entry)); } System.out.println("Listing all AnnouncementsPageEntry:"); for (AnnouncementsPageEntry entry : contentFeed.getEntries(AnnouncementsPageEntry.class)) { System.out.println(" title: " + entry.getTitle().getPlainText()); System.out.println(" id: " + getEntryId(entry)); System.out.println(" content: " + getContentBlob(entry)); } System.out.println("Listing all AnnouncementEntry:"); for (AnnouncementEntry entry : contentFeed.getEntries(AnnouncementEntry.class)) { System.out.println(" title: " + entry.getTitle().getPlainText()); System.out.println(" id: " + getEntryId(entry)); if (entry.getParentLink() != null) { System.out.println(" parent id: " + getEntryId(entry.getParentLink().getHref())); } System.out.println(" draft?: " + entry.isDraft()); System.out.println(" content: " + getContentBlob(entry)); } System.out.println("Listing all AttachmentEntry:"); for (AttachmentEntry entry : contentFeed.getEntries(AttachmentEntry.class)) { System.out.println(" title: " + entry.getTitle().getPlainText()); System.out.println(" id: " + getEntryId(entry)); if (entry.getParentLink() != null) { System.out.println(" parent id: " + getEntryId(entry.getParentLink().getHref())); } if (entry.getSummary() != null) { System.out.println(" description: " + entry.getSummary().getPlainText()); } System.out.println(" revision: " + entry.getRevision().getValue()); MediaContent content = (MediaContent) entry.getContent(); System.out.println(" src: " + content.getUri()); System.out.println(" content type: " + content.getMimeType().getMediaType()); } System.out.println("Listing all WebAttachmentEntry:"); for (WebAttachmentEntry entry : contentFeed.getEntries(WebAttachmentEntry.class)) { System.out.println(" title: " + entry.getTitle().getPlainText()); System.out.println(" id: " + getEntryId(entry)); if (entry.getParentLink() != null) { System.out.println(" parent id: " + getEntryId(entry.getParentLink().getHref())); } if (entry.getSummary() != null) { System.out.println(" description: " + entry.getSummary().getPlainText()); } System.out.println(" src: " + ((MediaContent) entry.getContent()).getUri()); } }
Nota:questo feed potrebbe richiedere o meno l'autenticazione. 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 Autenticazione nel servizio Sites.
Esempi di query sui feed di contenuti
Puoi cercare nel feed di contenuti utilizzando alcuni dei parametri di query standard dell'API di dati di Google. e quelle specifiche dell'API della versione classica di Sites. Per informazioni più dettagliate e un elenco completo dei parametri supportati, consulta Guida di riferimento.
Nota: gli esempi in questa sezione utilizzano il metodo buildContentFeedUrl()
in Recupero del feed di contenuti.
Recupero di tipi di voce specifici
Per recuperare solo un determinato tipo di voce, utilizza il parametro kind
. Questo esempio restituisce solo attachment
voci:
ContentQuery query = new ContentQuery(new URL(buildContentFeedUrl())); query.setKind("webpage"); ContentFeed contentFeed = client.getFeed(query, ContentFeed.class); for (AttachmentEntry entry : contentFeed.getEntries(AttachmentEntry.class)) { System.out.println(entry.getTitle().getPlainText()); }
Per restituire più di un tipo di voce, separa ogni kind
con una virgola. 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 in base al percorso
Se conosci il percorso relativo di una pagina all'interno del sito Google, puoi utilizzare il parametro path
per recuperare quella pagina specifica.
Questo esempio restituirebbe la pagina che si trova in
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 sotto una pagina principale
Se conosci l'ID dell'inserimento dei contenuti di una pagina (ad es. "1234567890" nell'esempio riportato di seguito), puoi utilizzare il parametro parent
per recuperare tutte le voci figlio (se presenti):
ContentQuery query = new ContentQuery(new URL(buildContentFeedUrl())); query.setParent("1234567890"); ContentFeed contentFeed = client.getFeed(query, ContentFeed.class);
Per ulteriori parametri, consulta la Guida di riferimento.
Creazione di 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 armadietto, pagine di annunci e così via) inviando un'istruzione 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
In questo esempio viene creato un nuovo webpage
sotto il livello più alto del sito e include un po' di codice HTML per il corpo della pagina.
e imposta il titolo 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 nei percorsi degli URL personalizzati
Per impostazione predefinita, l'esempio precedente viene creato nell'URL
http://sites.google.com/site/siteName/new-webpage-title
e
avere un'intestazione di pagina "Nuovo titolo della pagina web". In altre parole, il valore <atom:title>
è normalizzato in new-webpage-title
per l'URL.
Per personalizzare il percorso dell'URL di una pagina, puoi impostare l'elemento <sites:pageName>
.
In questo esempio viene creata una nuova pagina filecabinet
con l'intestazione "Archiviazione file", ma la pagina viene creata
dell'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:
<sites:pageName>
, se presente. Deve soddisfarea-z, A-Z, 0-9, -, _
.<atom:title>
non deve essere null se pageName non è presente. La normalizzazione consiste nel tagliare e comprimere lo spazio vuoto in "-" e rimuovi i caratteri non corrispondenti aa-z, A-Z, 0-9, -, _
.
Creazione di pagine secondarie
Per creare pagine secondarie (secondarie) sotto una pagina principale, devi impostare il link principale nella voce. L'attributo href
del link alla proprietà
del nodo padre.
public AnnouncementEntry postAnnouncement(String title, String content, AnnouncementsPageEntry parentPage) throws MalformedURLException, IOException, ServiceException { AnnouncementEntry entry = new AnnouncementEntry(); entry.setTitle(new PlainTextConstruct(title)); setContentBlob(entry, content); // Entry's HTML content // Set the entry's parent link to create the announcement under that page. entry.addLink(SitesLink.Rel.PARENT, Link.Type.ATOM, parentPage.getSelfLink().getHref()); return client.insert(new URL(buildContentFeedUrl()), entry); } ContentFeed contentFeed = client.getFeed(new URL(buildContentFeedUrl() + "?kind=announcementspage"), ContentFeed.class); AnnouncementEntry createdEntry = postAnnouncement("Party!!", "My place, this weekend", contentFeed.getEntries().get(0)); System.out.println("New post by " + createdEntry.getAuthors().get(0).getName());
L'esempio precedente crea un nuovo announcement
nella prima pagina degli annunci disponibile in
il feed di contenuti dell'utente. Il titolo dell'annuncio è impostato su "Festa!". e i contenuti di "La mia casa, questo weekend".
Modelli di pagina
Creazione di modelli di pagina
La procedura per creare un modello di pagina è la stessa della creazione di nuovi elementi/pagine e
creazione di pagine secondarie.La differenza è l'aggiunta di category
con termine ed etichetta impostati su "http://schemas.google.com/g/2005#template"
e "template", rispettivamente.
Questo esempio crea un nuovo modello webpage
.
// The template webpage entry. WebPageEntry entry = new WebPageEntry(); // Set title and content. entry.setTitle(new PlainTextConstruct("Page template title")); XmlBlob xml = new XmlBlob(); xml.setBlob("Content for page template"); entry.setContent(new XhtmlTextConstruct(xml)); // Set the template category Category TEMPLATE_CATEGORY = new Category(TemplateCategory.Scheme.LABELS, TemplateCategory.Term.TEMPLATE, TemplateCategory.Label.TEMPLATE); entry.getCategories().add(TEMPLATE_CATEGORY); // Insert the template webpage entry. WebPageEntry createdEntry = client.insert(new URL("https://sites.google.com/feeds/content/site/siteName"), entry);
Creazione di pagine da un modello
Come per la creazione di modelli di pagina, puoi creare un'istanza per una nuova pagina da un modello includendo un elemento <link>
con rel='http://schemas.google.com/sites/2008#template' puntare
al link stesso di un modello di pagina.
In questo esempio viene creato un nuovo modello filecabinet
e viene creata un'istanza per 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 <category>
, incluso uno nel
è comunque obbligatoria. Inoltre, se includi un elemento <content>
, il server lo rifiuterà.
Caricamento di file
Come in Google Sites, l'API supporta il caricamento degli allegati nella pagina dello schedario o in una pagina principale.
Per caricare un allegato a un genitore, invia una richiesta POST
HTTP all'URL del feed di contenuti:
https://sites.google.com/feeds/content/site/siteName
Tutti i tipi di allegati devono essere caricati su una pagina principale. Di conseguenza, imposti un link principale nella AttachmentEntry
o WebAttachmentEntry
che stai tentando di caricare. Per ulteriori informazioni, consulta la sezione Creazione di pagine secondarie.
Caricamento di allegati
In questo esempio viene caricato un file PDF nel primo FileCabinetPageEntry
trovato nel feed di contenuti dell'utente.
L'allegato viene creato con il titolo "Per iniziare" 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 viene eseguito correttamente, attachment
conterrà una copia della voce dell'allegato creato.
Caricamento di un allegato in una cartella
Per caricare un allegato in una cartella esistente in un FileCabinetPageEntry
, includi una categoria con la parola "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, si tratta di link ad altri file sul web che puoi aggiungere ai tuoi elenchi dei file armadietto. Questa funzione è analoga ad "Aggiungi file tramite URL" di caricamento nella UI di Google Sites.
Nota: gli allegati web possono essere creati solo in uno schedario. Non possono essere caricati su altri tipi di pagine.
In questo esempio viene creato un valore WebAttachmentEntry
sotto il primo FileCabinetPageEntry
trovato nel feed di contenuti dell'utente.
Il titolo e la descrizione (facoltativa) sono impostati su "GoogleLogo". e "colori piacevoli", 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 nell'armadietto dell'utente un link che rimanda all'immagine all'indirizzo "http://www.google.com/images/logo.gif".
Aggiornamento dei contenuti
Aggiornamento dei metadati e/o dei contenuti HTML di una pagina
I metadati (title, pageName ecc.) e i contenuti della pagina di qualsiasi tipo BaseContentEntry
possono essere modificati
utilizzando il metodo update()
della voce. Verrà inviata una richiesta PUT
HTTP al edit
della voce
.
Di seguito è riportato un esempio di aggiornamento di un ListPageEntry
con le seguenti modifiche:
- Il titolo viene modificato in "Titolo aggiornato"
- I contenuti HTML della pagina vengono aggiornati in "<p>Contenuti HTML aggiornati</p>"
- La prima intestazione di colonna dell'elenco viene modificata in "Proprietario"
ContentFeed contentFeed = client.getFeed( new URL(buildContentFeedUrl() + "?kind=listpage"), ContentFeed.class); ListPageEntry listPage = contentFeed.getEntries(ListPageEntry.class).get(0); // Update first list page found // Update title listPage.setTitle(new PlainTextConstruct("Updated Title")); // Update HTML content XmlBlob xml = new XmlBlob(); xml.setBlob("<p>Updated HTML Content</p>"); listPage.setContent(new XhtmlTextConstruct(xml)); // Change first column's heading listPage.getData().getColumns().get(0).setName("Owner"); // listPage.setPageName(new PageName("new-page-path")); // You can also change the page's URL path ListPageEntry updatedEntry = listPage.update(); System.out.println("ListPage updated!");
Aggiornamento dei contenuti del file allegato
Per AttachmentEntry
, puoi anche aggiornare i contenuti impostando il MediaSource
della voce e quindi utilizzando il
il metodo updateMedia(boolean)
della voce.
Questo esempio aggiornerà i contenuti di un allegato esistente:
public AttachmentEntry updateFile(AttachmentEntry entry, File newFile) throws IOException, ServiceException { // See Uploading Attachments for the definition of mediaTypes. entry.setMediaSource(new MediaFileSource(newFile, mediaTypes.getContentType(newFile))); return entry.updateMedia(false); }
L'esempio invia una richiesta PUT
HTTP al link edit-media
della voce. L'oggetto restituito
AttachmentEntry
includerà i contenuti aggiornati.
Aggiornamento dei metadati e dei contenuti degli allegati
Puoi aggiornare i metadati di un allegato e i relativi contenuti nella stessa chiamata utilizzando il metodo updateMedia()
.
Se puoi aggiornare solo i contenuti del file, i metadati o entrambi.
In questo esempio il titolo dell'allegato viene modificato in "Nuovo titolo", la descrizione viene aggiornata e i contenuti del file vengono sostituiti con un nuovo file ZIP.
Poiché la richiesta include nuovi contenuti di file, viene utilizzato il valore 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");
Eliminazione di contenuti
Per rimuovere una pagina o un elemento da un sito Google, devi prima recuperare la voce dei contenuti, quindi chiamare il delete()
della voce.
entry.delete();
Puoi anche utilizzare il metodo delete()
della classe di servizio passando il link edit
e il valore ETag della voce:
client.delete(entry.getEditLink().getHref(), "*"); // Note: using "*" may overwrite another client's changes.
Se la voce è stata eliminata, il server risponde con un 200 OK
HTTP.
Download degli allegati
Per scaricare AttachmentEntry
, invia una richiesta GET
HTTP al link src contenuto della voce.
Questo esempio scarica il primo AttachmentEntry
trovato nel feed di contenuti dell'utente
alla 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.");
Feed ACL
Panoramica delle autorizzazioni di condivisione (ACL)
Ogni voce ACL nel feed ACL rappresenta un ruolo di accesso di una particolare entità: 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. Ne verrà mostrata una sola per ogni indirizzo email nella sezione "Persone con accesso" nella schermata di condivisione della UI di Google Sites. Pertanto, gli amministratori di dominio non vengono mostrati, anche se hanno accesso implicito a un sito.
Ruoli
L'elemento Role rappresenta un livello di accesso che un'entità può avere. Esistono quattro possibili valori per l'elemento gAcl:role
:
- reader: un visualizzatore (equivalente all'accesso di sola lettura).
- writer: un collaboratore (equivalente all'accesso in lettura/scrittura).
- owner: in genere l'amministratore del sito (equivalente all'accesso in lettura/scrittura).
Ambiti
L'elemento ambito rappresenta l'entità con questo livello di accesso. Esistono quattro tipi possibili di elemento gAcl:scope
:
- utente: un valore dell'indirizzo email, ad esempio "utente@gmail.com".
- gruppo: l'indirizzo email di un gruppo Google, ad esempio "gruppo@dominio.com".
- domain: un nome di dominio G Suite, ad esempio "dominio.com".
- default: esiste un solo ambito possibile di tipo "default", che non ha alcun valore.
(ad es.
<gAcl:scope type="default">
). Questo particolare ambito controlla l'accesso di cui dispone per impostazione predefinita qualsiasi utente su un sito pubblico.
Nota: i domini non possono avere un valore gAcl:role
imposta su "proprietario" all'accesso, possono essere solo lettori o autori.
Recupero del feed ACL
Le classi AclFeed
e AclEntry
possono essere utilizzate per controllare la condivisione di un sito
autorizzazioni e può essere recuperato utilizzando il metodo getFeed()
della classe di servizio.
L'esempio seguente recupera il feed ACL per un determinato sito e stampa le autorizzazioni del
ogni AclEntry
:
public String getAclFeedUrl(String siteName) { String domain = "site"; // OR if the Site is hosted on G Suite, your domain (e.g. example.com) return "https://sites.google.com/feeds/acl/site/" + domain + "/" + siteName + "/"; } public void getAclFeed(String siteName) throws IOException, ServiceException { AclFeed aclFeed = client.getFeed(new URL(getAclFeedUrl(siteName)), AclFeed.class); for (AclEntry entry : aclFeed.getEntries()) { System.out.println(entry.getScope().getValue() + " (" + entry.getScope().getType() + ") : " + entry.getRole().getValue()); } } getAclFeed('my-site-name');
Se stai utilizzando le voci di SiteFeed, ogni SiteEntry
contiene un link al relativo feed ACL.
Ad esempio, questo snippet recupera il feed ACL di un SiteEntry
:
String aclLink = siteEntry.getLink(SitesAclFeedLink.Rel.ACCESS_CONTROL_LIST, Link.Type.ATOM).getHref(); AclFeed aclFeed = client.getFeed(new URL(aclLink), AclFeed.class);
Condividere un sito
Nota: alcuni ACL di condivisione potrebbero essere possibili solo se il dominio è configurato consentire queste autorizzazioni (ad esempio se è abilitata la condivisione all'esterno del dominio per i domini G Suite e così via).
Per condividere un sito Google utilizzando l'API, il cliente deve creare un nuovo
AclEntry
e POST
al server.
Ecco un esempio in cui viene aggiunto "utente@example.com" come reader
sul sito:
AclRole role = new AclRole("reader"); AclScope scope = new AclScope(AclScope.Type.USER, "user@example.com"); AclEntry aclEntry = addAclRole(role, scope, entry); public AclEntry addAclRole(AclRole role, AclScope scope, SiteEntry siteEntry) throws IOException, MalformedURLException, ServiceException { AclEntry aclEntry = new AclEntry(); aclEntry.setRole(role); aclEntry.setScope(scope); Link aclLink = siteEntry.getLink(SitesAclFeedLink.Rel.ACCESS_CONTROL_LIST, Link.Type.ATOM); return client.insert(new URL(aclLink.getHref()), aclEntry); }
Consulta la sezione Panoramica del feed ACL per i possibili AclScope
e AclRoles
.
Condivisione a livello di gruppo e di dominio
Analogamente alla condivisione di un sito con un singolo utente, puoi condividere un sito con un Gruppo Google o dominio G Suite.
Condivisione con l'indirizzo email di un gruppo:
AclScope scope = new AclScope(AclScope.Type.GROUP, "group_name@example.com");
Condivisione con un intero dominio:
AclScope scope = new AclScope(AclScope.Type.DOMAIN, "example.com");
La condivisione a livello di dominio è supportata solo per i domini G Suite e solo per il dominio su cui è ospitato il sito. Ad esempio, http://sites.google.com/a/dominio1.com/sitoA può solo condividere l'intero sito con dominio1.com, non dominio2.com. 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 innanzitutto l'AclEntry
in questione, modifica l'autorizzazione
come preferisci, quindi chiama il metodo update()
di AclEntry
per modificare l'ACL sul server.
Questo esempio modifica l'esempio precedente di aclEntry
dalla sezione Condivisione di un sito,
aggiornando "utente@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, devi prima recuperare AclEntry
, quindi chiamare 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.
Argomenti speciali
Recupero di un feed o di una voce
Se vuoi recuperare un feed o una voce già recuperati, puoi migliorare l'efficienza comunicando il server di inviare l'elenco o la voce solo se è stata modificata dall'ultima volta che l'hai recuperata.
Per eseguire questo tipo di recupero condizionale, entrambi i metodi getFeed()
e getEntry()
forniscono
Un argomento aggiuntivo che accetta un valore ETag o un oggetto DateTime
per l'intestazione If-Modified-Since
.
Puoi accedere all'etag di una voce da entry.getEtag()
.
Questo esempio esegue un recupero condizionale di una voce di pagina web di contenuti:
String feedUrl = "https://sites.google.com/feeds/content/site/siteName/123456789"; WebPageEntry entry = client.getEntry(new URL(feedUrl), WebPageEntry.class, "\"GVQHSARDQyp7ImBq\"");
Quando il server riceve questa richiesta, verifica se l'elemento richiesto ha lo stesso ETag
l'ETag specificato. Se gli ETag corrispondono, l'elemento non è cambiato e il server restituisce un
Verrà generata un'eccezione HTTP 304 NotModifiedException
.
Se gli ETag non corrispondono, l'elemento è stato modificato dopo l'ultima richiesta e il server lo restituisce.
Per ulteriori informazioni sugli ETag, consulta la guida di riferimento delle API di dati di Google.