Guia da linguagem Java

Importante:este documento foi escrito antes de 2012. As opções de autenticação descritos neste documento (OAuth 1.0, estrela e ConstraintLayout) foram oficialmente descontinuado desde 20 de abril de 2012 e não estão mais disponíveis. Recomendamos que você migre OAuth 2.0 assim que possível.

A API de dados do Google Sites permite que aplicativos clientes acessem, publiquem e modifiquem o conteúdo de um site Google. Seu aplicativo cliente também pode solicitar uma lista de atividades recentes, buscar o histórico de revisões e fazer o download de anexos.

Além de fornecer algumas informações sobre os recursos da API de dados do Google Sites, este guia fornece exemplos de interação com a API usando a biblioteca de cliente Java. Para receber ajuda na configuração da biblioteca de cliente, consulte Introdução à biblioteca de cliente Java de dados do Google. Se você tiver interesse entender mais sobre o protocolo usado pela biblioteca cliente Java para interagir com a API Sites clássico, consulte o guia de protocolos.

Público-alvo

Este documento se destina aos desenvolvedores que desejam criar aplicativos clientes que interajam com o Google Sites usando a biblioteca de cliente Java de dados do Google.

Primeiros passos

O Google Sites usa Contas do Google ou contas 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.

Instalar a biblioteca

Para receber ajuda na configuração e instalação da biblioteca de cliente, consulte Introdução à biblioteca de cliente Java de dados do Google. Se estiver usando o Eclipse, esse artigo também explica como configurar seu projeto usando o plug-in Eclipse das APIs de dados do Google. Confira o que é necessário para começar:

1. Instalar o Java 1.5 ou mais recente
2. Fazer o download da biblioteca de cliente (a versão mais recente de gdata-src.java.zip)
3. Faça o download da lista de dependências.
4. Faça o download dos aplicativos de exemplo (a versão mais recente do gdata-samples.java.zip)

Depois de instalar os arquivos .jars, você precisará incluir o seguinte em seu projeto:

1. java/lib/gdata-sites-2.0.jar – A versão 2.0 é destinada à versão 1.4 da API Sites clássica.
2. java/lib/gdata-core-1.0.jar
3. java/lib/gdata-client-1.0.jar
4. java/lib/gdata-spreadsheet-3.0.jar (se 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 gdata-samples.java.zip. A fonte também está disponível em /trunk/java/sample/sites/ no repositório do SVN, que pode ser acessado na guia "Origem". O SitesDemo.java permite que o usuário execute várias operações que demonstram como usar a API Sites clássico.

É necessário 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 do Eclipse.

Dependendo das necessidades do seu aplicativo, serão necessárias várias importações. Recomendamos começar com as seguintes 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 precisa 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 gerar 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 cliente Java pode ser usada para trabalhar com feeds públicos ou privados. A API Sites Data fornece acesso a recursos feeds, 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, o que exigiria um cliente autenticado. Isso pode ser feito via 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 mais informações sobre NGINX, OAuth e Systrace.

Dica: a API é compatível com SSL (HTTPS). Se você usa estrela/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 opção "Exigir SSL" no painel de controle administrativo é respeitada pela API. É possível forçar todas as solicitações de API sejam por HTTPS chamando client.useSsl();.

AuthSub para aplicativos da web

A autenticação Geocoding para aplicativos da Web deve ser usada por aplicativos clientes que precisam autenticam 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 O token vezes é obrigatório.

import com.google.gdata.client.*;

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

import com.google.gdata.client.*;

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

OAuth para aplicativos da Web ou instalados/para dispositivos móveis

O OAuth pode ser usado como uma alternativa ao GroupByKey e destina-se a aplicativos da Web. O OAuth é semelhante ao uso do modo seguro e registrado do Jinja em que todas as solicitações de dados devem ser assinadas digitalmente, e você deve registrar seu domínio.

Tensor para aplicativos instalados/móveis

O ClientLogin deve ser usado por aplicativos instalados ou para dispositivos móveis que precisam autenticam os usuários nas Contas do Google. Na primeira execução, o aplicativo solicita o nome de usuário/senha do usuário. Nas solicitações subsequentes, um token de autenticação é referenciado.

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

Voltar ao início

Feed do site

O feed de site pode ser usado para listar os sites do Google de um usuário ou para os quais ele tem permissões de visualização. Ele também pode ser usado 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 o site inteiro.

Listar sites

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, nome e tema do site. Outros getters estão disponíveis para acessar propriedades adicionais no feed.

Como criar novos 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() no feed do site.

Este exemplo cria um novo site 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 no domínio example.com do G Suite. Assim, o URL do site seria https://sites.google.com/a/example.com/my-site-title.

Se o site for criado corretamente, o servidor responderá com SiteEntry. , preenchido com elementos adicionados pelo servidor: um link para o site, um link para o feed da ACL do site, nome do site, título, resumo e assim por diante.

Copiar um site

Observação: esse recurso só está disponível para domínios do G Suite.

Copiar um site é semelhante à criação de um novo site. A diferença é que você precisa definir no novo SiteEntry que inclui o self link do site a ser duplicado. Aqui está um exemplo de duplicação do site criado na seção Como 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:

• Só é possível copiar sites e modelos de sites que o usuário autenticado possui.
• Um modelo de site também pode ser copiado. Um site é um modelo se a opção "Publicar este site como modelo" está marcada na página de configurações do Google Sites.
• Você pode copiar um site de outro domínio caso esteja listado como proprietário no site de origem.

Atualizar os metadados de um site

Para renomear um site, mudar o tema, a tag de categoria ou o resumo, primeiro você precisa buscar SiteEntry que contém o site em questão. modificar uma ou mais propriedades e 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

Os mapeamentos de endereços da Web permitem que os usuários do Google Sites mapeiem os próprios domínios para um site Google. Por exemplo, http://www.mydomainsite.com. pode ser usada em vez de http://sites.google.com/a/domain.com/mysite. Dependendo de onde seu site está hospedado, você pode modificar manualmente uma os mapeamentos de endereços da Web do seu site. Consulte nosso artigo da Central de Ajuda para mais informações.

Buscar os mapeamentos de endereços da Web de um site

Para retornar os mapeamentos de endereços 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 atuais vão aparecer como links com rel='webAddressMapping'. Por exemplo, no exemplo acima, há três webAddressMappings 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 devem especificar o parâmetro with-mappings=true ao trabalhar com mapeamentos de endereços da Web. Se o parâmetro estiver ausente, webAddressMappings não serão retornados nas entradas de site (GET) nem considerados ao atualizar/remover mapeamentos (PUT) de uma entrada.

Para adicionar, atualizar ou excluir um mapeamento, basta especificar, alterar ou remover esse 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ços, você precisa ser um administrador do site ou um administrador 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 de 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 ao criar/copiar um site.

Voltar ao início

Feed de atividades

Você pode buscar as atividades recentes (alterações) de um site buscando o feed de atividades. Cada entrada na o feed de atividades contém informações sobre uma mudança feita no site.

Para consultar o feed de atividades, envie um GET HTTP para o 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: para acessar o feed, você precisa ser um colaborador ou proprietário do site. Seu cliente deve ser autenticado usando um token noindex, OAuth ou Systrace. Consulte Como autenticar no serviço Sites.

Voltar ao início

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 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:para acessar o feed, você precisa ser um colaborador ou proprietário do site. Seu cliente deve ser autenticado usando um token noindex, OAuth ou Systrace. Consulte Como autenticar no serviço Sites.

Voltar ao início

Feed de conteúdo

Como recuperar o feed de conteúdo

O feed de conteúdo lista o conteúdo mais recente do site. Ele pode ser acessado enviando um GET HTTP para o URL do feed de conteúdo:

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

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 tipos diferentes de objetos, todos herdados de BaseContentEntry: ListItemEntry, ListPageEntry, AttachmentEntry, WebAttachmentEntry, FileCabinetPageEntry, AnnouncementsPageEntry, AnnouncementEntry, WebPageEntry e 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 exibidas 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:esse feed pode exigir ou não autenticação. dependendo das permissões de compartilhamento do site. Se o site não for público, o seu cliente deverá autenticar usando um token MRAID, OAuth ou Systrace. Consulte Como autenticar no serviço Sites.

Exemplos de consulta do feed de conteúdo

Você pode pesquisar o feed de conteúdo usando alguns dos parâmetros de consulta padrão da API de dados do Google e aqueles específicos da API Sites clássico. Para informações mais detalhadas e uma lista completa de parâmetros compatíveis, consulte a 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 attachment entradas:

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 uma ",". Esse exemplo retorna filecabinet e listpage entradas:

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ê sabe o caminho relativo de uma página no site Google, pode usar o parâmetro path para buscar essa página específica. Esse 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ê souber o ID de entrada de conteúdo de uma página (por exemplo, "1234567890" no exemplo abaixo), poderá 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.

Voltar ao início

Criação de conteúdo

Observação: antes de criar conteúdo para um site, configure o site no cliente.
client.site = "siteName";

Novo conteúdo (páginas da Web, de lista, de arquivo, de avisos etc.) pode ser criado enviando uma solicitação HTTP POST ao feed de conteúdo:

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

Para uma lista de tipos de nó de suporte, consulte o parâmetro kind no Guia de referência.

Criar novos itens / páginas

Esse exemplo cria um novo webpage no nível superior do site e inclui um código hexadecimal para o corpo da página. e define o título 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 conterá uma cópia da entrada criada no servidor.

Criar itens/páginas em caminhos de URL personalizados

Por padrão, o exemplo anterior seria criado no URL http://sites.google.com/site/siteName/new-webpage-title e tenham 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 título "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:

1. <sites:pageName>, se presente. Precisa atender a a-z, A-Z, 0-9, -, _.
2. <atom:title>, não poderá ser nulo se pageName não estiver presente. A normalização é cortar e recolher o espaço em branco para '-' e remove caracteres não correspondentes a a-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 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 em feed de conteúdo do usuário. O título do anúncio está definido como "Festa!" e o conteúdo para "Meu lugar, este fim de semana".

Modelos da página

Como criar modelos de página

O processo de criação de um modelo de página é o mesmo que o de criação de 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 "modelo", respectivamente.

Este exemplo cria 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

Semelhante à criação de modelos de página, você pode instanciar uma nova página 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: apesar de um modelo definir um <category>, incluindo um no seu ainda é necessária. Além disso, se você incluir um elemento <content>, ele será rejeitado pelo servidor.

Como fazer upload de arquivos

Assim como no Google Sites, a API permite o upload de anexos para uma página de arquivo ou uma página principal.

Para fazer o upload de um anexo em um arquivo pai, envie uma solicitação POST HTTP para o URL do feed de conteúdo:

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

É preciso fazer o upload de todos os tipos de anexos em uma página principal. Portanto, você definiu um link pai na AttachmentEntry ou WebAttachmentEntry que você está tentando enviar. Consulte Como criar subpáginas para mais informações.

Fazendo upload dos anexos

Este exemplo faz upload de um arquivo PDF para o primeiro FileCabinetPageEntry encontrado no feed de conteúdo do usuário. O anexo é criado com o título "Getting Started". e uma descrição (opcional), "Pacote 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 o upload for bem-sucedido, o attachment conterá uma cópia da entrada de anexo criada.

Fazer upload de um anexo para uma pasta

Para fazer upload de um anexo em uma pasta em um arquivo FileCabinetPageEntry, inclua uma categoria com o termo "termo". 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. Eles são links para outros arquivos na Web que você pode adicionar a suas listagens de arquivo. Esse recurso é análogo à opção "Adicionar arquivo por URL" de upload na interface do usuário do Google Sites.

Observação: anexos da Web só podem ser criados em um arquivo. Eles não podem ser enviados para outros tipos de páginas.

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) estão definidos como "GoogleLogo". e "cores bonitas", 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 que aponta para a imagem em "http://www.google.com/images/logo.gif".

Voltar ao início

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 pelo usando o método update() da entrada. Isso enviará uma solicitação PUT HTTP para o edit da entrada. .

Confira abaixo um exemplo de como atualizar um ListPageEntry com as seguintes mudanças:

• O título será modificado para "Título atualizado".
• O conteúdo HTML da página é atualizado para "<p>Conteúdo HTML atualizado</p>"
• O cabeçalho da primeira 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

No caso de AttachmentEntry, também é possível atualizar o conteúdo definindo o MediaSource da entrada e usando o método método updateMedia(boolean) da entrada.

Este exemplo atualizará o conteúdo de um anexo existente:

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 apresentará o conteúdo atualizado.

Atualizar os metadados e o 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 conteúdo novo, 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");

Voltar ao início

Excluindo conteúdo

Para remover uma página ou um item de um site Google, primeiro recupere a entrada de conteúdo e, em seguida, chame o 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 corretamente, o servidor responderá com um 200 OK HTTP.

Voltar ao início

Como fazer download de anexos

Para fazer o download de um AttachmentEntry, envie uma solicitação HTTP GET ao link src de conteúdo da entrada.

Este exemplo faz o download do primeiro AttachmentEntry encontrado no feed de conteúdo do usuário ao 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.");

Voltar ao início

Feed da ACL

Visão geral das permissões de compartilhamento (ACLs)

Cada entrada de ACL no feed de ACL representa um papel de acesso de uma entidade específica, seja um usuário, um grupo de usuários, um domínio, ou o acesso padrão (um site público). As entradas só serão mostradas para entidades com acesso explícito: uma entrada será mostrada para cada endereço de e-mail na seção "Pessoas com acesso" na tela de compartilhamento da interface do Google Sites. Assim, os administradores de domínio não serão exibidos, mesmo que tenham acesso implícito a um site.

Papéis

O elemento do papel representa o nível de acesso que uma entidade pode ter. Há quatro valores possíveis para o elemento gAcl:role:

• reader: um leitor (equivalente ao acesso somente leitura).
• writer: um colaborador (equivalente ao acesso de leitura/gravação).
• owner: geralmente 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 de um Grupo do Google, por exemplo, "group@domain.com".
• domain: um nome de domínio do G Suite, como "domain.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 "proprietário" acesso, eles só podem ser leitores ou escritores.

Como recuperar o feed da ACL

As classes AclFeed e AclEntry podem ser usadas para controlar o compartilhamento de um site permissões e podem ser buscadas usando o método getFeed() da classe de serviço.

O exemplo a seguir busca o feed da ACL de um determinado site e imprime as permissões de para 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 seu 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 ao servidor.

Aqui está um exemplo que adiciona "user@example.com" como 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 as possíveis AclScope e AclRoles.

Compartilhamento no nível do grupo e do domínio

Como no compartilhamento de um site com um único usuário, é possível compartilhar um site em uma 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 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 estiverem 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 o AclEntry em questão e modifique a permissão conforme desejado e, em seguida, chame o método update() de 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 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.

Voltar ao início

Tópicos especiais

Como recuperar um feed ou uma entrada novamente

Se você quiser recuperar um feed ou uma entrada que recuperou antes, pode melhorar a eficiência informando que o servidor envie a lista ou entrada somente se ela tiver sido alterada desde a última vez que você a recuperou.

Para fazer esse tipo de recuperação condicional, os métodos getFeed() e getEntry() fornecem um argumento adicional que aceite um valor de ETag ou um objeto DateTime para o cabeçalho If-Modified-Since. É possível acessar a ETag de uma entrada em entry.getEtag().

Este exemplo faz uma recuperação condicional para uma entrada de página de conteúdo:

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 o a ETag que você especificou. Se as ETags corresponderem, o item não foi alterado e o servidor retornará um A exceção NotModifiedException HTTP 304 será gerada.

Se as ETags não corresponderem, isso significa que o item foi modificado desde a última vez que você o solicitou e o servidor o retorna.

Para mais informações sobre ETags, consulte o Guia de referência das APIs de dados do Google.

Voltar ao início