Guia da linguagem Java

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

A API Google Sites Data permite que os aplicativos clientes acessem, publiquem e modifiquem o conteúdo em um site Google. O 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 alguns antecedentes sobre os recursos da API Sites Data, este guia apresenta exemplos de interação com a API usando a biblioteca de cliente Java. Para saber como configurar a biblioteca de cliente, consulte Como começar a usar a biblioteca de cliente Java do Google Data. Se você quiser saber mais sobre o protocolo usado pela biblioteca de cliente Java para interagir com a API Sites clássica, consulte o guia de protocolo.

Público-alvo

Este documento é destinado a desenvolvedores que querem criar aplicativos cliente que interagem com o Google Sites usando a Biblioteca de cliente Java de dados do Google.

Primeiros passos

O Google Sites usa Contas do Google ou do G Suite para autenticação. Se você já tem uma conta, está tudo pronto. Caso contrário, crie uma nova conta.

Instalar a biblioteca

Para saber como configurar e instalar a biblioteca de cliente, consulte Começar a usar a biblioteca de cliente Java do Google Data. Se você estiver usando o Eclipse, o artigo também explica como configurar seu projeto usando o Plug-in do Eclipse para as APIs Data do Google. Confira o que é necessário para começar:

1. Instale 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. Fazer o download da lista de dependências
4. Faça o download dos aplicativos de amostra (a versão mais recente do gdata-samples.java.zip).

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

1. java/lib/gdata-sites-2.0.jar: a versão 2.0 aqui é 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 de lista / itens de lista)

Além disso, inclua os frascos 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 origem também está disponível em /trunk/java/sample/sites/ no repositório SVN acessível na guia "Source". O SitesDemo.java permite que o usuário realize 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 Usar o Eclipse com as APIs Google Data para uma configuração rápida com nosso 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 vai precisar configurar um objeto SitesService, que representa uma conexão de cliente com a API clássica do Sites:

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 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 Sites e da operação que você está tentando executar. 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 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 oferece suporte a SSL (HTTPS). Se você estiver usando AuthSub/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. É possível forçar todas as solicitações de API a serem por HTTPS chamando client.useSsl();.

AuthSub para aplicativos da web

A Autenticação AuthSub para aplicativos da Web precisa ser usada por aplicativos clientes que precisam autenticar os usuários nas Contas do Google. O operador não precisa ter acesso ao nome de usuário e à senha do usuário do Google Sites. É necessário apenas um token AuthSub.

import com.google.gdata.client.*;

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

import com.google.gdata.client.*;

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

OAuth 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 a usar o modo seguro e registrado do GroupByKey, porque todas as solicitações de dados precisam ser assinadas digitalmente, e você precisa registrar seu domínio.

Tensor para aplicativos instalados/móveis

O ClientLogin precisa ser usado por aplicativos instalados ou para dispositivos móveis que precisam autenticar os usuários nas Contas do Google. Na primeira execução, o aplicativo solicita o nome de usuário/senha do usuário. Em 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 sites pode ser usado para listar os Sites Google que um usuário possui ou para os quais tem permissões de visualização. Também é possível usar esse comando para modificar o nome de um site existente. Para domínios do G Suite, também é possível usar o recurso para criar e/ou copiar um 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 de 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 outras propriedades no feed.

Criação de novos sites

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

Para provisionar novos sites, crie um novo SiteEntry e chame o método insert() do cliente no feed de sites.

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 será https://sites.google.com/a/example.com/my-site-title.

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

Copiar um site

Observação: esse recurso está disponível apenas 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 novo SiteEntry que inclua 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:

• Somente os sites e modelos de sites que pertencem ao usuário autenticado podem ser copiados.
• Um modelo de site também pode ser copiado. Um site é um modelo quando 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, desde que esteja 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 você precisa buscar o SiteEntry que contém o site em questão, modificar uma ou mais propriedades e chamar o método update() do SiteEntry. Neste exemplo, o tema do site anterior é modificado e o site é renomeado:

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 Sites mapeiem os próprios domínios para um site do 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 está hospedado, é possível modificar manualmente os mapeamentos de endereços da Web de um 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/o 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.

Como 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, webAddressMappings não serão retornados nas entradas do site (GET) nem considerados ao atualizar/remover (PUT) mapeamentos 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 do site. Observação: para atualizar os mapeamentos de endereço, você precisa ser um administrador do site ou um administrador de domínio no caso de um site hospedado no 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 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 no 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:

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 esse feed, você precisa ser um colaborador ou proprietário do site. O cliente precisa se autenticar usando um token AuthSub, OAuth ou ClientLogin. 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 depois busca o feed de revisão da 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 esse feed, você precisa ser um colaborador ou proprietário do site. O cliente precisa se autenticar usando um token AuthSub, OAuth ou ClientLogin. Consulte Como fazer a autenticação 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 de um 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 diferentes tipos de objetos, todos herdados de BaseContentEntry: ListItemEntry, ListPageEntry, AttachmentEntry, WebAttachmentEntry, FileCabinetPageEntry, AnnouncementsPageEntry, AnnouncementEntry, WebPageEntry, CommentEntry.

Confira um exemplo de como listar os 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: esse 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 cliente vai precisar fazer a autenticação usando um token AuthSub, OAuth ou ClientLogin. Consulte Como fazer a autenticação no serviço Sites.

Exemplos de consultas de feed de conteúdo

É possível pesquisar o feed de conteúdo usando alguns dos parâmetros de consulta padrão da API Data do Google e aqueles 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 desta 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 as 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 um ','. 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 Google Site, use 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";

É possível criar novos conteúdos (páginas da Web, páginas de listas, páginas de arquivos, páginas de avisos etc.) enviando um POST HTTP ao feed de conteúdo:

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

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

Criação de novos itens / páginas

Este exemplo cria um novo webpage no nível superior do site, inclui alguns XHTML para o corpo da página e define o título do cabeçalho como "New WebPage Title":

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 vai 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 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 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 ser a-z, A-Z, 0-9, -, _.
2. <atom:title>, não poderá ser nulo se pageName não estiver presente. A normalização é para recortar + reduzir espaços em branco para '-' e remover caracteres que não correspondem a a-z, A-Z, 0-9, -, _.

Como criar subpáginas

Para criar subpáginas (filhas filhas) em uma página principal, defina o link principal 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 uma nova 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, 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 criar novos itens/páginas e criar páginas secundárias. 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.

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

Assim como na criação de modelos de página, é possível instanciar uma nova página de um modelo incluindo um <link> com rel='http://schemas.google.com/sites/2008#template' que aponta 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>, ainda é necessário incluir um na entrada. Além disso, se você incluir um elemento <content>, o servidor vai rejeitá-lo.

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 upload de um anexo para um item pai, envie uma solicitação HTTP POST 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ê define um link pai no objeto AttachmentEntry ou WebAttachmentEntry que está tentando fazer upload. Consulte Como criar subpáginas para mais informações.

Fazendo upload dos anexos

Neste exemplo, um arquivo PDF é enviado para o primeiro FileCabinetPageEntry encontrado no feed de conteúdo do usuário. O anexo é criado com o título "Introdução" e uma descrição (opcional), "Pacote de RH".

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, attachment vai conter 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 em 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. Eles são links para outros arquivos na Web que podem ser adicionados às listagens. 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. Não é possível fazer upload delas 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) são definidos como "GoogleLogo" e "nice colors", 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 usando o método update() da entrada. Isso vai enviar uma solicitação HTTP PUT para o link edit da entrada.

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

• O título é 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!");

Como atualizar o conteúdo do arquivo de anexo

Para AttachmentEntry, também é possível atualizar o conteúdo definindo a MediaSource da entrada e usando o 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 retornado terá 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 você pode 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 contém um 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");

Voltar ao início

Excluindo conteúdo

Para remover uma página ou um item de um site do 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 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.");

Voltar ao início

Feed de 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 (que é 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 no painel "Pessoas com acesso" da tela de compartilhamento da interface do Google Sites. Assim, os administradores de domínio não vão aparecer, mesmo que tenham acesso implícito a um site.

Papéis

O elemento de função representa um 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).
• Escritor: um colaborador (equivalente ao acesso de leitura/gravação).
• proprietário: 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".
• grupo: um endereço de e-mail do Grupo do Google, por exemplo, "grupo@dominio.com".
• domain: um nome de domínio do G Suite, por exemplo, "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 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 mostra 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ó são possíveis se o domínio estiver configurado para permitir 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 do Google usando a API, o cliente precisa criar um novo AclEntry e POST para o 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 de ACL para conferir os possíveis valores de AclScope e AclRoles.

Compartilhamento em nível de grupo e domínio

Assim como compartilhar um site com um único usuário, você pode compartilhar um site em um grupo do Google ou domínio do G Suite.

Compartilhamento 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 é compatível apenas 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 domínio2.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 as permissões de compartilhamento

Para uma permissão de compartilhamento em um site, primeiro busque o AclEntry em questão, modifique a permissão conforme necessário e chame o método update() do AclEntry para modificar a ACL no servidor.

Este exemplo modifica o exemplo aclEntry anterior da seção Como compartilhar um site, atualizando "user@example.com" para 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.

Como remover 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

Temas especiais

Como recuperar um feed ou registro novamente

Se você quiser recuperar um feed ou uma entrada que já foi recuperada, pode melhorar a eficiência instruindo o servidor a enviar a lista ou a entrada somente se ela tiver mudado desde a última vez que foi recuperada.

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 a ETag de uma entrada em entry.getEtag().

Este exemplo faz uma recuperação condicional para uma entrada de página da Web 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 especificada. Se as ETags corresponderem, o item não será alterado e o servidor retornará uma exceção HTTP 304 NotModifiedException.

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