Importante:este documento foi escrito antes de 2012. As opções de autenticação descritas neste documento (OAuth 1.0, Twilio e gclid) foram oficialmente descontinuadas em 20 de abril de 2012 e não estão mais disponíveis. Recomendamos que você migre para o OAuth 2.0 assim que possível.
A API de dados do Google Sites permite que aplicativos clientes acessem, publiquem e modifiquem conteúdo em um site Google. Seu aplicativo cliente também pode solicitar uma lista das atividades recentes, buscar o histórico de revisões e fazer o download de anexos.
Além de fornecer algumas informações básicas sobre os recursos da API Sites Data, este guia fornece exemplos de interação com a API usando a biblioteca cliente Java. Para receber ajuda com a configuração da biblioteca de cliente, consulte Primeiros passos com a biblioteca de cliente Java de dados do Google. Para saber mais sobre o protocolo subjacente usado pela biblioteca de cliente do Java para interagir com a API Sites clássica, consulte o guia de protocolos.
Público-alvo
Este documento é para desenvolvedores que querem criar aplicativos cliente que interagem com o Google Sites usando a biblioteca de cliente Java de dados do Google.
Como começar
O Google Sites usa as Contas do Google ou do G Suite para fazer a autenticação. Se você já tem uma conta, não precisa fazer mais nada. Caso contrário, crie uma nova conta.
Instalar a biblioteca
Para receber ajuda na configuração e instalar a biblioteca de cliente, consulte Primeiros passos com a biblioteca de cliente Java de dados do Google. Se você estiver usando o Eclipse, este artigo também explica como configurar seu projeto usando o plug-in das APIs de dados do Google para o Eclipse. Veja aqui o que você precisa para começar:
- Instalar o Java 1.5 ou mais recente
- Faça o download da biblioteca de cliente (a versão mais recente de
gdata-src.java.zip
). - Fazer o download da lista de dependências
- Faça o download dos aplicativos de exemplo (a versão mais recente do
gdata-samples.java.zip
)
Depois de instalar os .jars, inclua o seguinte no seu projeto:
java/lib/gdata-sites-2.0.jar
: a versão 2.0 é destinada à versão 1.4 da API Sites clássico.java/lib/gdata-core-1.0.jar
java/lib/gdata-client-1.0.jar
java/lib/gdata-spreadsheet-3.0.jar
(se estiver trabalhando com páginas / itens de lista)
Além disso, inclua os jars de dependência (gdata-media-1.0.jar
, mail.jar
e google-collect....jar
).
Como executar o aplicativo de amostra
Um aplicativo de exemplo completo está localizado no subdiretório /java/sample/sites
do download do gdata-samples.java.zip
.
A origem também está disponível em /trunk/java/sample/sites/,
no repositório SVN, acessível na guia "Origem". Com o SitesDemo.java
, o usuário pode realizar várias operações que demonstram como usar a API Sites clássico.
Você precisará incluir java/sample/util/lib/sample-util.jar
para executar a amostra.
Como iniciar seu próprio projeto
Dica: consulte o artigo Como usar o Eclipse com as APIs de dados do Google para configurar rapidamente o plug-in Eclipse.
Dependendo das necessidades do seu aplicativo, serão necessárias várias importações. Recomendamos começar com estas importações:
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.*;
Em seguida, você também precisará configurar um objeto SitesService
, que representa uma conexão de cliente com a API Sites clássico:
SitesService client = new SitesService("yourCo-yourAppName-v1");
O argumento applicationName
precisa seguir o formato: company-applicationname-version
. Esse parâmetro é usado para fins de geração de registros.
Observação: o restante deste guia pressupõe que você criou um SitesService
na variável client
.
Como autenticar na API Sites clássico
A biblioteca de cliente Java pode ser usada para trabalhar com feeds públicos ou privados. A API Sites Data fornece acesso a feeds privados e públicos, dependendo das permissões do Google Sites e da operação que você está tentando realizar. Por exemplo, você pode ler o feed de conteúdo de um site público, mas não fazer atualizações nele, algo que exigiria um cliente autenticado. Isso pode ser feito por meio da autenticação de nome de usuário/senha do ClientLogin, AuthSub ou OAuth.
Consulte a Visão geral da autenticação das APIs de dados do Google para obter mais informações sobre Twilio, OAuth e ChromeVox.
Dica: a API é compatível com SSL (HTTPS). Se você estiver usando gclid/OAuth, especifique
um escopo de https://sites.google.com/feeds/
para solicitar feeds por SSL. Além disso, para domínios do G Suite, a configuração "Exigir SSL" no painel de controle administrativo é respeitada pela API. Chame client.useSsl();
para forçar todas as solicitações de API a serem feitas por HTTPS.
AuthSub para aplicativos da web
A autenticação IntelliJ para aplicativos da Web (em inglês) deve ser usada por aplicativos clientes que precisam autenticar os usuários nas Contas do Google. O operador não precisa de acesso ao nome de usuário e senha do usuário do Google Sites, apenas um token gclid é necessário.
Veja instruções para incorporar o EDGE ao seu aplicativo da Web
Solicitar um token de uso único
Quando o usuário acessa seu aplicativo pela primeira vez, ele precisa fazer a autenticação. Normalmente, os desenvolvedores imprimem alguns textos e um link que direcionam o usuário para a página de aprovação do Velostrata para autenticar o usuário e solicitar acesso aos documentos. A biblioteca de cliente Java de dados do Google fornece uma função para gerar esse URL. O código abaixo configura um link para a página 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 você quiser autenticar usuários no seu domínio hospedado pelo 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);
O método getRequestUrl()
usa vários parâmetros (correspondentes aos parâmetros de consulta usados pelo gerenciador AuthSubRequest):
- O próximo URL: URL para o qual o Google irá redirecionar
depois que o usuário fizer login na conta e conceder acesso.
http://www.example.com/welcome.jsp
no exemplo acima - No escopo:
https://sites.google.com/feeds/
no exemplo acima - um booleano para indicar se o token será usado no modo registrado ou não;
false
no exemplo acima - Um segundo booleano para indicar se o token será trocado por um token de sessão ou não.
true
no exemplo acima
Como fazer upgrade para um token de sessão
Consulte Como usar o Velostrata com as bibliotecas de cliente da API de dados do Google.
Como recuperar informações sobre um token de sessão
Consulte Como usar o Velostrata com as bibliotecas de cliente da API de dados do Google.
Como revogar um token de sessão
Consulte Como usar o Velostrata com as bibliotecas de cliente da API de dados do Google.
OAuth para aplicativos da Web ou instalados/dispositivos móveis
OAuth pode ser usado como uma alternativa para EDGE e se destina a aplicativos da Web. O OAuth é semelhante ao uso do modo seguro e registrado (link em inglês) de Twilio, em que todas as solicitações de dados precisam ser assinadas digitalmente, e você precisa registrar seu domínio.
Veja instruções para incorporar o OAuth ao aplicativo instalado
Como buscar um token de solicitação
Consulte Como usar o OAuth com as bibliotecas de cliente da API Google Data.
Como autorizar um token de solicitação
Consulte Como usar o OAuth com as bibliotecas de cliente da API Google Data.
Como fazer upgrade para um token de acesso
Consulte Como usar o OAuth com as bibliotecas de cliente da API Google Data.
GCLID para aplicativos instalados/móveis
ClientLogin é usado por aplicativos instalados ou móveis que precisam autenticar seus usuários nas Contas do Google. Na primeira execução, o aplicativo solicita ao usuário o nome de usuário e a senha. Nas solicitações subsequentes, um token de autenticação será referenciado.
Veja instruções para incorporar o GCLID a seu aplicativo instalado
Para usar o ClientLogin, invoque o método
setUserCredentials()
do objeto SitesService
, que é herdado de
GoogleService
. Especifique o endereço de e-mail e a senha do usuário
em nome de quem o cliente está fazendo solicitações. Exemplo:
SitesService client = new SitesService("yourCo-yourAppName-v1"); client.setUserCredentials("example@gmail.com", "pa$$word");
Dica: depois que o aplicativo autenticar o usuário pela primeira vez, armazene o token de autenticação no banco de dados para consultar para uso posterior. Não é necessário solicitar a senha do usuário sempre que o aplicativo for executado. Consulte Como chamar um token de autenticação para mais informações.
Para obter mais informações sobre o uso de GCLID em seus aplicativos Java, consulte Uso de GCLID com as bibliotecas cliente da API de dados do Google.
Feed do site
O feed de site pode ser usado para listar os Google Sites de que um usuário é proprietário ou tem permissões de visualização. Ela também pode ser usada para modificar o nome de um site existente. Para domínios do G Suite, ele também pode ser usado para criar e/ou copiar um site inteiro.
Sites de listagem
Para consultar o feed do site, envie um GET
HTTP para o URL do feed do site:
https://sites.google.com/feeds/site/site/
No cliente Java, use as classes SiteFeed
e SiteEntry
para trabalhar com o feed do site:
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(""); } }
O snippet acima imprime o título, o nome e o tema do site. Outros getters estão disponíveis para acessar outras propriedades no feed.
Criação de sites
Observação: esse recurso só está disponível para domínios do G Suite.
Para provisionar novos sites, crie um novo SiteEntry
e chame o método insert()
do cliente no feed.
Este exemplo cria um site novo com o tema "barreira" (configuração opcional) e fornece o nome do site (obrigatório) e a descrição (opcional):
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");
A solicitação acima criaria um novo site com o domínio do G Suite example.com
.
Assim, o URL do site seria https://sites.google.com/a/exemplo.com/título-do-site.
Se o site for criado, o servidor responderá com um objeto SiteEntry
, preenchido com elementos adicionados pelo servidor: um link para o site, um link para o feed da ACL do site, o nome do site, o título, o resumo e assim por diante.
Como copiar um site
Observação: esse recurso só está disponível para domínios do G Suite.
Copiar um site é semelhante a criar um novo site. A diferença é que você precisa definir um
link no seu novo SiteEntry
que inclua o self link do site a ser duplicado.
Este é um exemplo de duplicação do site criado na seção Criar novos sites:
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);
Pontos importantes:
- Somente sites e modelos de sites que pertencem ao usuário autenticado podem ser copiados.
- Também é possível copiar um modelo de site. Um site é um modelo se a configuração "Publicar este site como um modelo" estiver marcada na página de configurações do Google Sites.
- Você pode copiar um site de outro domínio enquanto não estiver listado como proprietário no site de origem.
Como atualizar os metadados de um site
Para renomear um site, mudar o tema, a tag de categoria ou o resumo, primeiro será necessário buscar o SiteEntry
que contém o site em questão, modificar uma ou mais propriedades e, em seguida, chamar o método update()
do SiteEntry
.
Este exemplo modifica o tema do site anterior e renomeia o site:
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();
Mapeamentos de endereços da Web
Com os mapeamentos de endereços da Web, os usuários do Google Sites podem mapear os próprios domínios para um site Google. Por exemplo, http://www.mydomainsite.com
pode ser usado em vez de http://sites.google.com/a/domain.com/mysite
. Dependendo de onde seu site estiver hospedado, você poderá modificar manualmente os mapeamentos de endereços da Web. Consulte nosso artigo da Central de Ajuda para mais informações.
Como buscar os mapeamentos de endereços da Web de um site
Para retornar os mapeamentos de endereço da Web de um site, busque a entrada/feed do site com o parâmetro 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()); } }
Os mapeamentos existentes serão exibidos como link
s com rel='webAddressMapping'. Por exemplo, no exemplo acima,
há três webAddressMapping
s que apontam para o site
http://sites.google.com/site/myOtherTestSite
.
Modificar mapeamentos de endereços da Web
Observação: todas as operações GET/POST/PUT precisam especificar o parâmetro with-mappings=true
ao trabalhar com mapeamentos de endereços da Web. Se o parâmetro estiver ausente, webAddressMapping
s não serão retornados nas entradas do site (GET) nem serão considerados ao atualizar/remover mapeamentos (PUT) de uma entrada.
Para adicionar, atualizar ou excluir um mapeamento, basta especificar, alterar ou remover o link ao criar novos sites ou atualizar os metadados de um site. O parâmetro with-mappings=true
precisa ser incluído no URI do feed de site.
Observação: para atualizar os mapeamentos de endereço, você precisa ser um administrador do site ou do domínio, no caso de um site hospedado pelo G Suite.
Por exemplo, a solicitação abaixo atualiza o mapeamento http://www.mysitemapping.com
para http://www.my-new-sitemapping.com
e remove o http://www.mysitemapping2.com
deixando o link fora da entrada:
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();
Observação: os mapeamentos de endereços da Web também podem ser especificados no momento da criação/cópia de um site.
Feed de atividades
Você pode buscar as atividades recentes de um site (alterações) buscando o feed de atividades. Cada entrada no feed de atividades contém informações sobre uma alteração feita no site.
Para consultar o feed de atividades, envie um GET
HTTP ao URL do feed de atividades:
https://sites.google.com/feeds/activity/site/siteName
No cliente Java, use a classe ActivityFeed
para retornar objetos 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()); } }
Observação: o acesso a esse feed requer que você seja um colaborador ou proprietário do site. Seu cliente deve autenticar usando um token gclid, OAuth ou ChromeVox. Consulte Como autenticar no serviço do Google Sites.
Feed de revisão
Para buscar o histórico de revisões de qualquer entrada de conteúdo, envie um GET
HTTP para o link de revisão da entrada:
https://sites.google.com/feeds/revision/site/siteName/CONTENT_ENTRY_ID
Este exemplo consulta o feed de conteúdo e, em seguida, busca o feed de revisão para a primeira entrada de conteúdo:
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()); } }
Observação:o acesso a esse feed requer que você seja um colaborador ou proprietário do site. Seu cliente deve autenticar usando um token gclid, OAuth ou ChromeVox. Consulte Como autenticar no serviço do Google Sites.
Feed de conteúdo
Como recuperar o feed de conteúdo
O feed de conteúdo lista o conteúdo mais recente de um site. Ela pode ser acessada enviando um HTTP GET
para o URL do feed de conteúdo:
https://sites.google.com/feeds/content/site/siteName
Parâmetro de feed | Descrição |
---|---|
site | "site " ou o domínio do seu domínio hospedado do G Suite (por exemplo, example.com ). |
siteName | O nome do espaço Web do seu site, encontrado no URL do site (por exemplo, mySite ). |
Exemplo de busca do feed de conteúdo:
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);
O contentFeed
resultante é um objeto ContentFeed
que contém a resposta do servidor. Cada entrada
de contentFeed
representa uma página ou um item diferente no site do usuário. O ContentFeed
vai conter diferentes tipos
de objetos, todos herdados de BaseContentEntry
: ListItemEntry
, ListPageEntry
, AttachmentEntry
, WebAttachmentEntry
,
FileCabinetPageEntry
, AnnouncementsPageEntry
, AnnouncementEntry
, WebPageEntry
, CommentEntry
.
Veja um exemplo de listagem dos diferentes tipos de entradas em um ContentFeed
.
Cada tipo de entrada contém propriedades diferentes, mas nem todas são mostradas aqui.
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()); } }
Observação:o feed pode ou não exigir autenticação, dependendo das permissões de compartilhamento do site. Se o site não for público, o seu cliente deverá fazer a autenticação usando um token EDGE, OAuth ou gclid. Consulte Como autenticar no serviço do Google Sites.
Exemplos de consulta de feed de conteúdo
Você pode pesquisar o feed de conteúdo usando alguns dos parâmetros de consulta padrão da API Google Data e alguns específicos da API Sites clássica. Para informações mais detalhadas e uma lista completa de parâmetros compatíveis, consulte o Guia de referência.
Observação: os exemplos nesta seção usam o método buildContentFeedUrl()
em Como recuperar o feed de conteúdo.
Como recuperar tipos de entrada específicos
Para buscar apenas um tipo específico de entrada, use o parâmetro kind
. Este exemplo retorna apenas entradas attachment
:
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()); }
Para retornar mais de um tipo de entrada, separe cada kind
com ",". Este exemplo retorna entradas filecabinet
e
listpage
:
URL url = new URL(buildContentFeedUrl() + "?kind=filecabinet,listpage"); ContentFeed contentFeed = client.getFeed(url, ContentFeed.class); for (FileCabinetPageEntry entry : contentFeed.getEntries(FileCabinetPageEntry.class)) { System.out.println(" title: " + entry.getTitle().getPlainText()); } for (ListPageEntry entry : contentFeed.getEntries(ListPageEntry.class)) { System.out.println(" title: " + entry.getTitle().getPlainText()); }
Como recuperar uma página por caminho
Se você souber o caminho relativo de uma página no site Google, poderá usar o parâmetro path
para buscar essa página específica.
Este exemplo retornaria a página localizada em
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()); }
Como recuperar todas as entradas em uma página pai
Se você conhece o ID de entrada de conteúdo de uma página (por exemplo, "1234567890" no exemplo abaixo), é possível usar o parâmetro parent
para buscar todas as entradas filhas (se houver):
ContentQuery query = new ContentQuery(new URL(buildContentFeedUrl())); query.setParent("1234567890"); ContentFeed contentFeed = client.getFeed(query, ContentFeed.class);
Para parâmetros adicionais, consulte o Guia de referência.
Criação de conteúdo
Observação:antes de criar conteúdo para um site, verifique se você configurou o site no cliente.client.site = "siteName";
Para criar conteúdo novo (páginas da Web, de listas, de arquivos, de avisos etc.), envie um POST
de HTTP
para o feed de conteúdo:
https://sites.google.com/feeds/content/site/siteName
Para ver uma lista de tipos de nós de suporte, consulte o parâmetro kind
no Guia de referência.
Criar novos itens / páginas
Este exemplo cria um novo webpage
no nível superior do site, inclui um código HTML para o corpo da página e define o título do cabeçalho como "Novo título da página da 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 a solicitação for bem-sucedida, createdEntry
terá uma cópia da entrada criada no servidor.
Como criar itens/páginas em caminhos de URL personalizados
Por padrão, o exemplo anterior seria criado sob o URL
http://sites.google.com/site/siteName/new-webpage-title
e
teria o cabeçalho "Novo título da página da Web". Ou seja, o <atom:title>
é normalizado para new-webpage-title
no URL.
Para personalizar o caminho do URL de uma página, defina o elemento <sites:pageName>
.
Este exemplo cria uma nova página filecabinet
com o cabeçalho "Armazenamento de arquivos", mas cria a página
no URL http://sites.google.com/site/siteName/files
(em vez de http://sites.google.com/site/siteName/file-storage
)
especificando o 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());
O servidor usa as seguintes regras de precedência para nomear o caminho do URL de uma página:
<sites:pageName>
, se presente. Precisa atender aa-z, A-Z, 0-9, -, _
.<atom:title>
, não poderá ser nulo se pageName não estiver presente. A normalização consiste em cortar e recolher o espaço em branco para "-" e remover os caracteres que não correspondem aa-z, A-Z, 0-9, -, _
.
Como criar subpáginas
Para criar subpáginas (filhos) em uma página pai, é necessário definir o link pai na entrada. O atributo href
do link para o self link do nó pai.
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());
O exemplo acima cria um novo announcement
na primeira página de avisos encontrada no feed de conteúdo do usuário. O título do anúncio é definido como "Festa!" e o conteúdo como "Meu lugar, neste fim de semana".
Modelos da página
Como criar modelos de página
O processo para criar um modelo de página é igual a criar novos itens/páginas e criar subpáginas.A diferença é a adição de category
com o termo e o rótulo definidos como "http://schemas.google.com/g/2005#template" e "template", respectivamente.
Neste exemplo, criamos um novo modelo 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);
Como criar páginas com base em um modelo
Assim como na criação de modelos de página, é possível instanciar uma nova página a partir de um modelo incluindo um <link>
com rel='http://schemas.google.com/sites/2008#template' apontando
para o self link de um modelo de página.
Este exemplo cria um novo modelo filecabinet
e, em seguida, instancia uma nova página filecabinet
a partir desse modelo.
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);
Observação: mesmo que um modelo defina um <category>
, ainda é necessário incluir um na
entrada. Além disso, se você incluir um elemento <content>
, o servidor o rejeitará.
Como fazer upload de arquivos
Assim como no Google Sites, a API suporta o upload de anexos em uma página de arquivo ou em uma página principal.
Para fazer o upload de um anexo para um pai, envie uma solicitação POST
HTTP para o URL do feed de conteúdo:
https://sites.google.com/feeds/content/site/siteName
Todos os tipos de anexo precisam ser enviados para uma página principal. Portanto, defina um link pai no objeto AttachmentEntry
ou WebAttachmentEntry
que você está tentando enviar. Consulte Como criar subpáginas para mais informações.
Fazendo upload dos anexos
Este exemplo faz o upload de um arquivo PDF para a primeira FileCabinetPageEntry
encontrada no feed de conteúdo do usuário.
O anexo é criado com o título "Getting Started" e uma descrição (opcional) como "HR package".
MimetypesFileTypeMap mediaTypes = new MimetypesFileTypeMap(); mediaTypes.addMimeTypes("application/msword doc"); mediaTypes.addMimeTypes("application/vnd.ms-excel xls"); mediaTypes.addMimeTypes("application/pdf pdf"); mediaTypes.addMimeTypes("text/richtext rtx"); // ... See a more complete list of mime types in the SitesHelper.java public AttachmentEntry uploadAttachment(File file, BasePageEntry<?> parentPage, String title, String description) throws IOException, ServiceException { AttachmentEntry newAttachment = new AttachmentEntry(); newAttachment.setMediaSource(new MediaFileSource(file, mediaTypes.getContentType(file))); newAttachment.setTitle(new PlainTextConstruct(title)); newAttachment.setSummary(new PlainTextConstruct(description)); newAttachment.addLink(SitesLink.Rel.PARENT, Link.Type.ATOM, parentPage.getSelfLink().getHref()); return client.insert(new URL(buildContentFeedUrl()), newAttachment); } ContentFeed contentFeed = client.getFeed(new URL(buildContentFeedUrl() + "?kind=filecabinet"), ContentFeed.class); FileCabinetPageEntry parentPage = contentFeed.getEntries(FileCabinetPageEntry.class).get(0); AttachmentEntry attachment = uploadAttachment( new File("/path/to/your/file.pdf"), parentPage, "Getting Started", "HR packet"); System.out.println("Uploaded!");
Se o upload der certo, attachment
terá uma cópia da entrada de anexo criada.
Fazer upload de um anexo para uma pasta
Para fazer upload de um anexo para uma pasta existente em um FileCabinetPageEntry
, inclua uma categoria com o atributo "term" definido como o nome da pasta.
Por exemplo, adicione esta linha em uploadAttachment()
:
newAttachment.getCategories().add(new Category("http://schemas.google.com/sites/2008#folder", "FolderName"));
Anexos da Web
Anexos da Web são tipos especiais de anexos. Em essência, eles são links para outros arquivos na Web que você pode adicionar às suas listagens de arquivo. Esse recurso é análogo ao método de upload "Adicionar arquivo por URL" na interface do Google Sites.
Observação: os anexos da Web só podem ser criados em um arquivo. Eles não podem ser enviados para outros tipos de página.
Este exemplo cria um WebAttachmentEntry
no primeiro FileCabinetPageEntry
encontrado no feed de conteúdo do usuário.
O título e a descrição (opcional) são definidos como "GoogleLogo" e "nice cores", respectivamente.
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!");
O POST
cria um link no arquivo do usuário apontando para a imagem em "http://www.google.com/images/logo.gif".
Atualizar conteúdo
Atualizar os metadados e/ou o conteúdo HTML de uma página
Os metadados (título, pageName etc.) e o conteúdo da página de qualquer tipo BaseContentEntry
podem ser editados
usando o método update()
da entrada. Isso enviará uma solicitação HTTP PUT
para o link edit
da entrada.
Confira abaixo um exemplo de atualização de um ListPageEntry
com as seguintes mudanças:
- O título é modificado para "Título atualizado"
- O conteúdo HTML da página foi atualizado para "<p>Conteúdo HTML atualizado</p>"
- O primeiro cabeçalho de coluna da lista é alterado para "Proprietário"
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!");
Atualizando o conteúdo do arquivo anexo
Para AttachmentEntry
, você também pode atualizar o conteúdo definindo o MediaSource
da entrada e, em seguida, usando o
método updateMedia(boolean)
da entrada.
Este exemplo vai atualizar o conteúdo de um anexo:
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); }
O exemplo envia uma solicitação HTTP PUT
para o link edit-media
da entrada. O AttachmentEntry
retornado terá o conteúdo atualizado.
Atualizar metadados e conteúdo do anexo
É possível atualizar os metadados e o conteúdo de um anexo na mesma chamada usando o método updateMedia()
.
Se for possível atualizar apenas o conteúdo do arquivo, os metadados ou ambos.
Este exemplo altera o título do anexo para "Novo título", atualiza sua descrição e substitui o conteúdo do arquivo por um novo arquivo .zip.
Como a solicitação inclui novo conteúdo de arquivo, o updateMedia()
do AttachmentEntry
é usado.
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");
Exclusão de conteúdo
Para remover uma página ou um item de um site Google, primeiro recupere a entrada do conteúdo e chame o método delete()
da entrada.
entry.delete();
Você também pode usar o método delete()
da classe de serviço transmitindo o link edit
da entrada e o valor da ETag:
client.delete(entry.getEditLink().getHref(), "*"); // Note: using "*" may overwrite another client's changes.
Se a entrada tiver sido excluída, o servidor responderá com um 200 OK
HTTP.
Fazendo o download de anexos
Para fazer o download de um AttachmentEntry
, envie uma solicitação HTTP GET
para o link src de conteúdo da entrada.
Este exemplo faz o download do primeiro AttachmentEntry
encontrado no feed de conteúdo do usuário
para o diretório "/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 da ACL
Visão geral das permissões de compartilhamento (ACLs)
Cada entrada no feed da ACL representa uma função de acesso de uma entidade específica, seja um usuário, um grupo de usuários, um domínio ou o acesso padrão (que é um site público). As entradas serão exibidas apenas para entidades com acesso explícito: uma entrada será mostrada para cada endereço de e-mail no painel "Pessoas com acesso" na tela de compartilhamento da interface do Google Sites. Assim, os administradores de domínio não serão mostrados, mesmo que tenham acesso implícito a um site.
Papéis
O elemento role representa um nível de acesso que uma entidade pode ter. Há quatro valores possíveis para o elemento gAcl:role
:
- reader: um visualizador (equivalente ao acesso somente leitura).
- writer: um colaborador (equivalente ao acesso de leitura/gravação).
- owner: normalmente, o administrador do site (equivalente ao acesso de leitura/gravação).
Escopos
O elemento de escopo representa a entidade que tem esse nível de acesso. Há quatro tipos possíveis do elemento gAcl:scope
:
- user: um valor de endereço de e-mail, por exemplo, "user@gmail.com".
- group: um endereço de e-mail do Grupo do Google, por exemplo, "grupo@dominio.com".
- domínio: um nome de domínio do G Suite, por exemplo, "domínio.com".
- default: há apenas um escopo possível do tipo "default", que não tem valor (por exemplo,
<gAcl:scope type="default">
). Esse escopo específico controla o acesso que qualquer usuário tem por padrão em um site público.
Observação: os domínios não podem ter um valor gAcl:role
definido como acesso de "proprietário". Eles só podem ser leitores ou gravadores.
Como recuperar o feed da ACL
As classes AclFeed
e AclEntry
podem ser usadas para controlar as permissões de
compartilhamento de um site e podem ser buscadas usando o método getFeed()
da classe de serviço.
O exemplo a seguir busca o feed de ACL de um determinado site e imprime as permissões de cada 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 você estiver trabalhando com entradas no SiteFeed, cada SiteEntry
conterá um link para seu feed da ACL.
Por exemplo, este snippet busca o feed "ACL" de um SiteEntry
:
String aclLink = siteEntry.getLink(SitesAclFeedLink.Rel.ACCESS_CONTROL_LIST, Link.Type.ATOM).getHref(); AclFeed aclFeed = client.getFeed(new URL(aclLink), AclFeed.class);
Como compartilhar um site
Observação: algumas ACLs de compartilhamento só serão possíveis se o domínio estiver configurado para conceder essas permissões. Por exemplo, se o compartilhamento fora do domínio para domínios do G Suite estiver ativado etc.
Para compartilhar um site Google usando a API, seu cliente precisa criar um novo
AclEntry
e POST
no servidor.
Confira um exemplo que adiciona "user@example.com" como um reader
no site:
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); }
Consulte a seção Visão geral do feed da ACL para ver os possíveis valores AclScope
e AclRoles
.
Compartilhamento no nível do grupo e do domínio
De forma semelhante ao compartilhamento de um site com um único usuário, o compartilhamento pode ser feito em um grupo do Google ou domínio do G Suite.
Como compartilhar com um endereço de e-mail de grupo:
AclScope scope = new AclScope(AclScope.Type.GROUP, "group_name@example.com");
Compartilhamento com um domínio inteiro:
AclScope scope = new AclScope(AclScope.Type.DOMAIN, "example.com");
O compartilhamento no nível do domínio só é compatível com domínios do G Suite e apenas com o domínio em que o site está hospedado. Por exemplo, http://sites.google.com/a/domain1.com/siteA só pode compartilhar o site inteiro com dominio1.com, não com dominio2.com. Sites que não estejam hospedados em um domínio do G Suite (por exemplo, http://sites.google.com/site/siteB) não podem convidar domínios.
Modificar permissões de compartilhamento
Para uma permissão de compartilhamento existente em um site, primeiro busque a AclEntry
em questão, modifique a permissão conforme desejado e chame o método update()
do AclEntry
para modificar a ACL no servidor.
Este exemplo modifica nosso exemplo anterior de aclEntry
da seção Como compartilhar um site, atualizando "user@example.com" para ser um writer
(colaborador):
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);
Para mais informações sobre ETags, consulte o Guia de referência das APIs de dados do Google.
Removendo permissões de compartilhamento
Para remover uma permissão de compartilhamento, primeiro recupere o AclEntry
e, em seguida, chame o método delete()
:
aclEntry.delete(); // Could also use the client's delete method // client.delete(new URL(aclEntry.getEditLink().getHref()), aclEntry);
Para mais informações sobre ETags, consulte o Guia de referência das APIs de dados do Google.
Temas especiais
Como recuperar um feed ou uma entrada novamente
Se você quiser recuperar um feed ou uma entrada recuperada anteriormente, poderá melhorar a eficiência solicitando que o servidor envie a lista ou a entrada somente se ela tiver sido alterada desde a última vez em que você a recuperou.
Para fazer esse tipo de recuperação condicional, os métodos getFeed()
e getEntry()
fornecem um argumento adicional que aceita um valor de ETag ou um objeto DateTime
para o cabeçalho If-Modified-Since
.
É possível acessar o ETag de uma entrada a partir de entry.getEtag()
.
Este exemplo faz uma recuperação condicional de uma entrada de conteúdo da página da Web:
String feedUrl = "https://sites.google.com/feeds/content/site/siteName/123456789"; WebPageEntry entry = client.getEntry(new URL(feedUrl), WebPageEntry.class, "\"GVQHSARDQyp7ImBq\"");
Quando o servidor recebe essa solicitação, ele verifica se o item solicitado tem a mesma ETag que você especificou. Se as ETags corresponderem, o item não foi alterado e o servidor retornará uma exceção NotModifiedException
HTTP 304.
Se as ETags não corresponderem, o item foi modificado desde a última solicitação, e o servidor o retorna.
Para mais informações sobre ETags, consulte o Guia de referência das APIs de dados do Google.