Uma versão recriada do Sites foi lançada em 22 de novembro de 2016. A API Sites não pode acessar nem modificar os sites criados com esta versão, mas ainda pode acessar o Sites clássico.

Guia da linguagem Java

Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

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

A API de dados do Google Sites permite que os aplicativos cliente acessem, publiquem e modifiquem conteúdo em 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 site, este guia fornece exemplos para interagir com a API usando a biblioteca de cliente Java. Se precisar de ajuda para configurar a biblioteca de cliente, consulte Primeiros passos com a biblioteca de cliente Java de dados do Google. Se você quiser entender mais sobre o protocolo subjacente usado pela biblioteca de cliente Java para interagir com a API Sites clássica, consulte o guia de protocolo.

Público-alvo

Este documento é para os desenvolvedores criarem aplicativos clientes que interajam com o Google Sites usando a Biblioteca de cliente Java dos dados do Google.

Primeiros passos

O Google Sites usa Contas do Google ou contas do G Suite para autenticação. Se você já tem uma conta, não precisa fazer mais nada. Caso contrário, crie uma nova conta.

Instalar a biblioteca

Se precisar de ajuda para configurar e instalar a biblioteca de cliente, consulte Introdução à biblioteca de cliente Java de dados do Google. Se você está usando o Eclipse, este artigo também explica como configurar seu projeto usando o plug-in do Eclipse das APIs de dados do Google. Para começar, siga estas instruções:

  1. Instalar o Java 1.5 ou mais recente
  2. Faça o download da biblioteca de cliente (a versão mais recente do 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 o .jars, será necessário 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 / itens de listas)

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á funcionando no subdiretório /java/sample/sites do download do gdata-samples.java.zip. A fonte também está disponível em /SSH/java/sample/sites/ (link em inglês) no repositório SVN acessível na guia "Source". O SitesDemo.java permite que o usuário execute várias operações que demonstram como usar a API Sites clássica.

Você precisa 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 com nosso plug-in do Eclipse.

Dependendo das necessidades do seu aplicativo, você precisará de 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 precisará configurar um objeto SitesService, que representa uma conexão de cliente com a API Sites clássica:

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

O argumento applicationName precisa seguir o formato: company-applicationname-version. Esse parâmetro é usado para fins de registro.

Observação: no restante deste guia, presumimos que você tenha criado um SitesService na variável client.

Como autenticar na API Sites clássica

A biblioteca de cliente Java pode ser usada para trabalhar com feeds públicos ou privados. A API Sites Data fornece acesso a feeds públicos e particulares, dependendo das permissões do 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 pode fazer atualizações nele, algo que exige um cliente autenticado. Isso pode ser feito usando a autenticação de nome de usuário/senha do ClientLogin, o tmp ou o OAuth.

Consulte Visão geral da autenticação das APIs de dados do Google para mais informações sobre tmp, OAuth e ClientLogin.

Dica: a API é compatível com SSL (HTTPS). Se você estiver usando XPN/OAuth, especifique um escopo de https://sites.google.com/feeds/ para solicitar feeds por SSL. 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 por HTTPS chamando client.useSsl();.

AuthSub para aplicativos da web

A autenticação do OAuth para aplicativos da Web deve ser usada por aplicativos clientes que precisam autenticar usuários para contas do Google. O operador não precisa de acesso ao nome de usuário e à senha do usuário do Google Sites. Apenas um token tmp é necessário.

Veja instruções para incorporar o XPN em seu aplicativo da Web

Solicitar um token de uso único

Quando o usuário acessa seu aplicativo pela primeira vez, ele precisa fazer a autenticação. Normalmente, os desenvolvedores imprimem um texto e um link que direciona o usuário para a página de aprovação do SMTP, para autenticar o usuário e solicitar acesso aos documentos. A biblioteca de cliente Java dos dados do Google fornece uma função para gerar esse URL. O código abaixo configura um link para a página tmpRequest.

import com.google.gdata.client.*;

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

Se você quiser autenticar usuários no seu domínio hospedado do G Suite:

import com.google.gdata.client.*;

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

O método getRequestUrl() usa vários parâmetros (correspondentes aos parâmetros de consulta usados pelo gerenciador tmpRequest):

  • o próximo URL: URL ao qual o Google vai redirecionar depois que o usuário fizer login na conta e conceder acesso; http://www.example.com/welcome.jsp no exemplo acima
  • o escopohttps://sites.google.com/feeds/ no exemplo acima
  • um booleano para indicar se o token será usado no modo registrado ou não. false no exemplo acima
  • um segundo booleano para indicar se o token será trocado por um token de sessão posteriormente (true no exemplo acima)

Como fazer upgrade para um token de sessão

Consulte Como usar tmp com as bibliotecas de cliente da API Google Data.

Como recuperar informações sobre um token de sessão

Consulte Como usar tmp com as bibliotecas de cliente da API Google Data.

Revogar um token de sessão

Consulte Como usar tmp com as bibliotecas de cliente da API Google Data.

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

O OAuth pode ser usado como uma alternativa para o tmp. Ele é destinado a aplicativos da Web. O OAuth é parecido com o uso do modo seguro e registrado do ISBN, em que todas as solicitações de dados precisam ser assinadas digitalmente e você precisa registrar seu domínio.

Veja instruções para incorporar o OAuth ao aplicativo instalado

Como buscar um token de solicitação

Consulte Como usar o OAuth com as bibliotecas de cliente da API Google Data.

Como autorizar um token de solicitação

Consulte Como usar o OAuth com as bibliotecas de cliente da API Google Data.

Como fazer upgrade para um token de acesso

Consulte Como usar o OAuth com as bibliotecas de cliente da API Google Data.

ClientLogin para aplicativos instalados/móveis

O ClientLogin deve ser usado por aplicativos instalados ou móveis que precisem autenticar seus usuários em Contas do Google. Na primeira execução, seu aplicativo solicita ao usuário seu nome de usuário/senha. Nas próximas solicitações, um token de autenticação será referenciado.

Ver instruções para incorporar ClientLogin no aplicativo instalado

Para usar ClientLogin, invoque o método setUserCredentials() do objeto SitesService, que é herdado de GoogleService. Especifique o endereço de e-mail e a senha do usuário em nome de quem seu cliente está fazendo solicitações. Exemplo:

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

Dica: depois que o aplicativo autenticar o usuário pela primeira vez, armazene o token de autenticação no banco de dados para recuperá-lo e usá-lo posteriormente. Não é necessário solicitar a senha do usuário em cada execução do aplicativo. Consulte Como recuperar um token de autenticação para mais informações.

Para mais informações sobre como usar o ClientLogin nos seus aplicativos Java, consulte Como usar o ClientLogin com as bibliotecas de cliente da API Google Data.

Voltar ao início

Feed do site

O feed pode ser usado para listar os sites Google de que um usuário é proprietário ou 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 site inteiro.

Como listar sites

Para consultar o feed do site, envie um GET HTTP para o URL do feed:

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

No cliente Java, use as classes SiteFeed e SiteEntry para trabalhar com o feed de sites:

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

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

O snippet acima imprime o título, o nome e o tema do site. Outros getters estão disponíveis para acessar outras propriedades no feed.

Criar novos sites

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

Para provisionar novos sites, crie um novo SiteEntry e chame o método insert() do cliente 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 do G Suite example.com. Assim, o URL do site seria https://sites.google.com/a/example.com/meu-site-título.

Se o site for criado com sucesso, o servidor vai responder com um objeto SiteEntry, preenchido com elementos adicionados por ele: um link para o site, um link para o feed acl do site, o nome do site, o título, o resumo e assim por diante.

Copiar um site

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

A ação de copiar um site é semelhante a criar um novo site. A diferença é que você precisa definir um link no novo SiteEntry que inclua o link próprio do site para ser duplicado. Veja um exemplo de como duplicar o site criado na seção Criar novos sites:

public SiteEntry copySite(String title, String summary, String sourceHref)
    throws MalformedURLException, IOException, ServiceException {
  SiteEntry entry = new SiteEntry();
  entry.setTitle(new PlainTextConstruct(title));
  entry.setSummary(new PlainTextConstruct(summary));
  entry.addLink(SitesLink.Rel.SOURCE, Link.Type.ATOM, sourceHref);

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

String sourceHref = newSiteEntry.getLink(SitesLink.Rel.SOURCE, Link.Type.ATOM).getHref();
SiteEntry myTwin = copySite("Duplicate Site", "A copy", sourceHref);

Pontos importantes:

  • Só é possível copiar sites e modelos de site de propriedade do usuário autenticado.
  • Também é possível copiar um modelo de site. Um site será um modelo se a configuração "Publicar este site como modelo" estiver 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 metadados de um site

Para renomear um site, mudar o tema, a tag de categoria ou o resumo, primeiro é necessário buscar o SiteEntry contendo o site em questão, modificar uma ou mais propriedades e, em seguida, chamar o método update() do SiteEntry. Este exemplo modifica o tema do site anterior e renomeia o site:

myTwin.setTitle(new PlainTextConstruct("better-title"));

Theme theme = myTwin.getTheme();
theme.setValue('iceberg');
myTwin.setTheme(theme);

myTwin.getCategories().add(new Category(TagCategory.Scheme.TAG, "newTag", null));

SiteEntry updatedSiteEntry = myTwin.update();

System.out.println(updatedSiteEntry.getTitle().getPlainText();

Mapeamentos de endereços da Web

Com os mapeamentos de endereços da Web, os usuários do Sites podem mapear os próprios domínios para um site Google. Por exemplo, http://www.mydomainsite.com pode ser usado em vez de http://sites.google.com/a/domain.com/mysite. Dependendo do local em que 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.

Buscando mapeamentos de endereços da Web de um site

Para retornar os mapeamentos de endereços da Web de um site, busque o feed/a entrada do site com o parâmetro with-mappings=true:

SiteQuery query = new SiteQuery(new URL("https://sites.google.com/feeds/site/siteName"));
query.setWithMappings(true);

SiteFeed feed = service.getFeed(query, SiteFeed.class);
for (SiteEntry entry : feed.getEntries()) {
  System.out.println("Mappings for '" + entry.getSiteName().getValue() + "':");
  for (Link link : entry.getWebAddressMappingLinks()) {
    System.out.println("  " + link.getHref());
  }
}

Os mapeamentos existentes serão exibidos como 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) ou 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 do site. Observação: para atualizar os mapeamentos de endereço, você precisa ser um administrador do site ou do domínio no caso de um site hospedado 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();

Os mapeamentos de endereços da Web também podem ser especificados no momento da criação/cópia de um site.

Voltar ao início

Feed de atividades

Você pode buscar a atividade recente (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 ao 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 colaborador ou proprietário do site. O cliente precisa fazer a autenticação usando um token tmp, OAuth ou ClientLogin. Consulte Como autenticar no serviço do Google 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:o acesso a este feed exige que você seja um colaborador ou proprietário do site. O cliente precisa fazer a autenticação usando um token tmp, OAuth ou ClientLogin. Consulte Como autenticar no serviço do Google 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. Ela pode ser acessada enviando um GET HTTP para o URL do feed de conteúdo:

https://sites.google.com/feeds/content/site/siteName
Parâmetro do feedDescrição
site"site" ou o domínio do seu domínio hospedado do G Suite (por exemplo, example.com).
siteNameO nome do espaço do site, encontrado no URL do site (por exemplo, mySite).

Exemplo de como buscar o 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 item diferente no site do usuário. O ContentFeed conterá diferentes tipos de objetos, todos herdados de BaseContentEntry: ListItemEntry, ListPageEntry, AttachmentEntry, WebAttachmentEntry, FileCabinetPageEntry, AnnouncementsPageEntry, AnnouncementEntry, WebPageEntry, CommentEntry.

Veja um exemplo de como listar os diferentes tipos de entrada 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: este feed pode ou não exigir autenticação, dependendo das permissões de compartilhamento do site. Se o site não for público, seu cliente deve autenticar usando um token tmp, OAuth ou ClientLogin. Consulte Como autenticar no serviço do Google Sites.

Exemplos de consulta de feed de conteúdo

É possível pesquisar o feed de conteúdo usando alguns dos parâmetros de consulta padrão da API Google Data e outros específicos da API Sites clássica. Para informações mais detalhadas e uma lista completa de parâmetros compatíveis, consulte o Guia de referência.

Observação: os exemplos nesta seção usam o método buildContentFeedUrl() em Como recuperar o feed de conteúdo.

Como recuperar tipos de entrada específicos

Para buscar apenas um tipo específico de entrada, use o parâmetro kind. Este exemplo retorna apenas entradas attachment:

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

Para retornar mais de um tipo de entrada, separe cada kind com 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ê sabe o caminho relativo de uma página no site Google, pode usar o parâmetro path para buscar essa página específica. Este exemplo retornaria a página localizada em http://sites.google.com/site/siteName/path/to/the/page:

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

Como recuperar todas as entradas em uma página pai

Se você souber o ID da 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 ver mais parâmetros, 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, verifique se você o definiu no cliente.
client.site = "siteName";

Novos conteúdos (páginas da Web, páginas de listas, páginas de arquivos, páginas de avisos etc.) podem ser criados enviando um POST HTTP ao feed de conteúdo:

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

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

Como criar novos itens / páginas

Este exemplo cria um novo webpage no nível superior do Site, inclui um 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 conterá uma cópia da entrada criada no servidor.

Como criar itens/páginas em caminhos de URL personalizados

Por padrão, o exemplo anterior seria criado no URL http://sites.google.com/site/siteName/new-webpage-title e teria um título de página "Novo título da página da Web". Ou seja, a <atom:title> é normalizada para new-webpage-title no URL. Para personalizar o caminho do URL de uma página, defina o elemento <sites:pageName>.

Esse exemplo cria uma nova página filecabinet com um título de "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 houver. Precisa atender a a-z, A-Z, 0-9, -, _.
  2. <atom:title>, não pode ser nulo se pageName não estiver presente. A normalização é cortar + recolher o espaço 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 (filhos) em uma página mãe, você precisa definir o link pai na entrada. O atributo href do link para o self link do nó pai.

public AnnouncementEntry postAnnouncement(String title, String content, AnnouncementsPageEntry parentPage)
    throws MalformedURLException, IOException, ServiceException {
  AnnouncementEntry entry = new AnnouncementEntry();
  entry.setTitle(new PlainTextConstruct(title));

  setContentBlob(entry, content); // Entry's HTML content

  // Set the entry's parent link to create the announcement under that page.
  entry.addLink(SitesLink.Rel.PARENT, Link.Type.ATOM, parentPage.getSelfLink().getHref());

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

ContentFeed contentFeed = client.getFeed(new URL(buildContentFeedUrl() + "?kind=announcementspage"), ContentFeed.class);

AnnouncementEntry createdEntry = postAnnouncement("Party!!", "My place, this weekend", contentFeed.getEntries().get(0));
System.out.println("New post by " + createdEntry.getAuthors().get(0).getName());

O exemplo acima cria um novo announcement na primeira página de avisos encontrada no feed de conteúdo do usuário. O título do anúncio está definido como "Festa!", e o conteúdo, como "Meu lugar, neste fim de semana".

Modelos de página

Como criar modelos de página

O processo para criar um modelo de página é o mesmo que criar novos itens/páginas e criar subpáginas.A diferença é a adição de category com os termos e rótulos 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 usando um modelo

Assim como na criação de modelos de página, é possível instanciar uma nova página a partir de um modelo, incluindo um <link> com rel='http://schemas.google.com/sites/2008#template' apontando para o link próprio de um modelo de página.

Este exemplo cria um novo modelo filecabinet e, em seguida, instancia uma nova página filecabinet desse modelo.

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

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

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

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

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

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

Observação: mesmo que seja necessário definir um modelo na <category>, incluindo um na sua entrada ainda é necessário. 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 é compatível com o upload de anexos para a página de arquivo ou uma página pai.

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

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

Todos os tipos de anexo precisam ser enviados à página mãe. Portanto, defina um link pai no objeto AttachmentEntry ou WebAttachmentEntry que você está tentando enviar. Consulte Como criar subpáginas para ver 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 um título de "Vamos começar" 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 conterá uma cópia da entrada de anexo criada.

Como fazer upload de um anexo para uma pasta

Para fazer upload de um anexo em uma pasta existente de um FileCabinetPageEntry, inclua uma categoria com o atributo "term" definido no 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. Basicamente, elas são links para outros arquivos na Web que podem ser adicionados às suas fichas de arquivos. Esse recurso é semelhante ao método de upload "Adicionar arquivo por URL" na IU do Google Sites.

Observação: os anexos da Web só podem ser criados em um arquivo. Elas não podem ser enviadas para outros tipos de página.

Este exemplo cria um WebAttachmentEntry no primeiro FileCabinetPageEntry encontrado no feed de conteúdo do usuário. O título e a descrição (opcional) 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 que aponta para a imagem em "http://www.google.com/images/logo.gif".

Voltar ao início



Atualizando conteúdo

Atualizar metadados e/ou conteúdo HTML de uma página

Os metadados (título, pageName etc.) e o conteúdo das páginas de qualquer tipo BaseContentEntry podem ser editados usando o método update() da entrada. Isso envia uma solicitação PUT HTTP para o link edit da entrada.

Veja abaixo um exemplo de atualização de uma ListPageEntry com as seguintes mudanças:

  • O título foi modificado para "Título atualizado".
  • O conteúdo HTML da página é atualizado para "<p>Conteúdo HTML atualizado</p>"
  • O título 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!");

Atualizar o conteúdo do arquivo anexado

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

Este exemplo atualiza o conteúdo de um anexo:

public AttachmentEntry updateFile(AttachmentEntry entry, File newFile)
    throws IOException, ServiceException {
  // See Uploading Attachments for the definition of mediaTypes.
  entry.setMediaSource(new MediaFileSource(newFile, mediaTypes.getContentType(newFile)));
  return entry.updateMedia(false);
}

O exemplo envia uma solicitação PUT HTTP para o link edit-media da entrada. A AttachmentEntry retornada vai ter o conteúdo atualizado.

Atualizar metadados e conteúdo do anexo

É possível atualizar os metadados e o conteúdo de um anexo na mesma chamada usando o método updateMedia(). Se 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 a descrição dele e substitui o conteúdo do arquivo por um novo arquivo ZIP. Como a solicitação contém um novo conteúdo do arquivo, o updateMedia() da 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



Exclusão de conteúdo

Para remover uma página ou item de um site Google, primeiro recupere a entrada de conteúdo e, depois, chame o delete() da entrada.

entry.delete();

Também é possível usar o método delete() da classe de serviço transmitindo o link edit e o valor ETag da entrada:

client.delete(entry.getEditLink().getHref(), "*"); // Note: using "*" may overwrite another client's changes.

Se a entrada for excluída, o servidor vai 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 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 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 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: um usuário, um grupo de usuários, um domínio ou o acesso padrão (que é um site público). As entradas serão mostradas somente para entidades com acesso explícito. Uma entrada será mostrada para cada endereço de e-mail no painel "Pessoas com acesso" na tela de compartilhamento da IU do Google Sites. Assim, os administradores do domínio não serão exibidos, mesmo que tenham acesso implícito a um site.

Papéis

O elemento de papel 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).
  • writer: um colaborador (equivalente ao acesso de leitura/gravação).
  • owner: normalmente o administrador do site (equivalente ao acesso de leitura/gravação).

Escopos

O elemento de escopo representa a entidade que tem esse nível de acesso. Há quatro tipos possíveis de elemento gAcl:scope:

  • user: um valor de endereço de e-mail, por exemplo, "usuario@gmail.com".
  • group: um endereço de e-mail do Grupo do Google, como "grupo@dominio.com".
  • domain: um nome de domínio do G Suite, por exemplo, "dominio.com".
  • default: há apenas um escopo possível do tipo "padrão", 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 de ACL

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

O exemplo a seguir busca o feed de ACL de um determinado site e imprime as permissões de cada AclEntry:

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

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

getAclFeed('my-site-name');

Se você estiver trabalhando com entradas no SiteFeed, cada SiteEntry conterá um link para o feed da ACL dele. 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);

Compartilhar um site

Observação: algumas ACLs de compartilhamento só podem ser 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 Google usando a API, o cliente precisa criar um novo AclEntry e POST ao servidor.

Veja 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 os possíveis valores AclScope e AclRoles.

Compartilhamento nos níveis do grupo e do domínio

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

Compartilhar com um endereço de e-mail de grupo:

AclScope scope = new AclScope(AclScope.Type.GROUP, "group_name@example.com");

Compartilhar com um domínio inteiro:

AclScope scope = new AclScope(AclScope.Type.DOMAIN, "example.com");

O compartilhamento no nível do domínio só é compatível com domínios do G Suite e apenas com o domínio em que o site está hospedado. Por exemplo, o domínio http://sites.google.com/a/domain1.com/siteA só pode compartilhar o site inteiro com o domínio1.com, não o domínio2.com. Os sites que não estão hospedados em um domínio do G Suite (por exemplo, http://sites.google.com/site/siteB) não podem convidar domínios.

Modificando as permissões de compartilhamento

Para uma permissão de compartilhamento existente em um site, busque a AclEntry em questão, modifique a permissão conforme desejado e, em seguida, chame o método update() da 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 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 de APIs de dados do Google.

Removendo permissões de compartilhamento

Para remover uma permissão de compartilhamento, primeiro recupere o AclEntry e, em seguida, chame o método delete():

aclEntry.delete();

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

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

Voltar ao início

Tópicos especiais

Como recuperar um feed ou uma entrada novamente

Se você quer recuperar um feed ou entrada recuperado anteriormente, é possível melhorar a eficiência informando ao servidor para enviar 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 aceita um valor de ETag ou um objeto DateTime para o cabeçalho If-Modified-Since. Você pode 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 que a especificada. Se as ETags coincidirem, o item não mudou e o servidor retornará uma exceção NotModifiedException HTTP 304.

Se as ETags não corresponderem, o item foi modificado desde a última solicitação, e o servidor retornará o item.

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

Voltar ao início