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.

Esta página foi traduzida pela API Cloud Translation.

Guia da linguagem Java

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

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

Além de fornecer algumas informações básicas sobre os recursos da API Sites Data, este guia fornece exemplos de interação com a API usando a biblioteca cliente Java. Para receber ajuda com a configuração da biblioteca de cliente, consulte Primeiros passos com a biblioteca de cliente Java de dados do Google. Para saber mais sobre o protocolo subjacente usado pela biblioteca de cliente do Java para interagir com a API Sites clássica, consulte o guia de protocolos.

Público-alvo

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

Como começar

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

Instalar a biblioteca

Para receber ajuda na configuração e instalar a biblioteca de cliente, consulte Primeiros passos com a biblioteca de cliente Java de dados do Google. Se você estiver usando o Eclipse, este artigo também explica como configurar seu projeto usando o plug-in das APIs de dados do Google para o Eclipse. Veja aqui o que você precisa para começar:

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

Depois de instalar os .jars, inclua o seguinte no seu projeto:

java/lib/gdata-sites-2.0.jar: a versão 2.0 é destinada à versão 1.4 da API Sites clássico.
java/lib/gdata-core-1.0.jar
java/lib/gdata-client-1.0.jar
java/lib/gdata-spreadsheet-3.0.jar (se estiver trabalhando com páginas / itens de lista)

Além disso, inclua os jars de dependência (gdata-media-1.0.jar, mail.jar e google-collect....jar).

Como executar o aplicativo de amostra

Um aplicativo de exemplo completo está localizado no subdiretório /java/sample/sites do download do gdata-samples.java.zip. A origem também está disponível em /trunk/java/sample/sites/, no repositório SVN, acessível na guia "Origem". Com o SitesDemo.java, o usuário pode realizar várias operações que demonstram como usar a API Sites clássico.

Você precisará incluir java/sample/util/lib/sample-util.jar para executar a amostra.

Como iniciar seu próprio projeto

Dica: consulte o artigo Como usar o Eclipse com as APIs de dados do Google para configurar rapidamente o plug-in Eclipse.

Dependendo das necessidades do seu aplicativo, serão necessárias várias importações. Recomendamos começar com estas importações:

import com.google.gdata.client.*;
import com.google.gdata.client.sites.*;
import com.google.gdata.data.*;
import com.google.gdata.data.acl.*;
import com.google.gdata.data.media.*;
import com.google.gdata.data.sites.*;
import com.google.gdata.data.spreadsheet.*;  // If working with listpages / listitems
import com.google.gdata.util.*;

Em seguida, você também precisará configurar um objeto SitesService, que representa uma conexão de cliente com a API Sites clássico:

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

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

Observação: o restante deste guia pressupõe que você criou um SitesService na variável client.

Como autenticar na API Sites clássico

A biblioteca de cliente Java pode ser usada para trabalhar com feeds públicos ou privados. A API Sites Data fornece acesso a feeds privados e públicos, dependendo das permissões do Google Sites e da operação que você está tentando realizar. Por exemplo, você pode ler o feed de conteúdo de um site público, mas não fazer atualizações nele, algo que exigiria um cliente autenticado. Isso pode ser feito por meio da autenticação de nome de usuário/senha do ClientLogin, AuthSub ou OAuth.

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

Dica: a API é compatível com SSL (HTTPS). Se você estiver usando gclid/OAuth, especifique um escopo de https://sites.google.com/feeds/ para solicitar feeds por SSL. Além disso, para domínios do G Suite, a configuração "Exigir SSL" no painel de controle administrativo é respeitada pela API. Chame client.useSsl(); para forçar todas as solicitações de API a serem feitas por HTTPS.

AuthSub para aplicativos da web

A autenticação IntelliJ para aplicativos da Web (em inglês) deve ser usada por aplicativos clientes que precisam autenticar os usuários nas Contas do Google. O operador não precisa de acesso ao nome de usuário e senha do usuário do Google Sites, apenas um token gclid é necessário.

Veja instruções para incorporar o EDGE ao seu aplicativo da Web

Solicitar um token de uso único

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

import com.google.gdata.client.*;

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

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

import com.google.gdata.client.*;

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

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

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

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

OAuth pode ser usado como uma alternativa para EDGE e se destina a aplicativos da Web. O OAuth é semelhante ao uso do modo seguro e registrado (link em inglês) de Twilio, em que todas as solicitações de dados precisam ser assinadas digitalmente, e você precisa registrar seu domínio.

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

Como buscar um token de solicitação

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

Como autorizar um token de solicitação

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

Como fazer upgrade para um token de acesso

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

GCLID para aplicativos instalados/móveis

ClientLogin é usado por aplicativos instalados ou móveis que precisam autenticar seus usuários nas Contas do Google. Na primeira execução, o aplicativo solicita ao usuário o nome de usuário e a senha. Nas solicitações subsequentes, um token de autenticação será referenciado.

Veja instruções para incorporar o GCLID a seu aplicativo instalado

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

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

Dica: depois que o aplicativo autenticar o usuário pela primeira vez, armazene o token de autenticação no banco de dados para consultar para uso posterior. Não é necessário solicitar a senha do usuário sempre que o aplicativo for executado. Consulte Como chamar um token de autenticação para mais informações.

Para obter mais informações sobre o uso de GCLID em seus aplicativos Java, consulte Uso de GCLID com as bibliotecas cliente da API de dados do Google.

Voltar ao início

Feed do site

O feed de site pode ser usado para listar os Google Sites de que um usuário é proprietário ou tem permissões de visualização. Ela também pode ser usada para modificar o nome de um site existente. Para domínios do G Suite, ele também pode ser usado para criar e/ou copiar um site inteiro.

Sites de listagem

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

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

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

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

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

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

Criação de sites

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

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

Este exemplo cria um site novo com o tema "barreira" (configuração opcional) e fornece o nome do site (obrigatório) e a descrição (opcional):

public String getSiteFeedUrl() {
  String domain = "example.com";
  return "https://sites.google.com/feeds/site/" + domain + "/";
}

public SiteEntry createSite(String title, String summary, String theme, String tag)
    throws MalformedURLException, IOException, ServiceException {
  SiteEntry entry = new SiteEntry();
  entry.setTitle(new PlainTextConstruct(title));
  entry.setSummary(new PlainTextConstruct(summary));

  Theme tt = new Theme();
  tt.setValue(theme);
  entry.setTheme(tt);

  entry.getCategories().add(new Category(TagCategory.Scheme.TAG, tag, null));

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

SiteEntry newSiteEntry = createSite("My Site Title", "summary for site", "slate", "tag");

A solicitação acima criaria um novo site com o domínio do G Suite example.com. Assim, o URL do site seria https://sites.google.com/a/exemplo.com/título-do-site.

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

Como copiar um site

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

Copiar um site é semelhante a criar um novo site. A diferença é que você precisa definir um link no seu novo SiteEntry que inclua o self link do site a ser duplicado. Este é um exemplo de duplicação do site criado na seção Criar novos sites:

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

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

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

Pontos importantes:

Somente sites e modelos de sites que pertencem ao usuário autenticado podem ser copiados.
Também é possível copiar um modelo de site. Um site é um modelo se a configuração "Publicar este site como um modelo" estiver marcada na página de configurações do Google Sites.
Você pode copiar um site de outro domínio enquanto não estiver listado como proprietário no site de origem.

Como atualizar os metadados de um site

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

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

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

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

SiteEntry updatedSiteEntry = myTwin.update();

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

Mapeamentos de endereços da Web

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

Como buscar os mapeamentos de endereços da Web de um site

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

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

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

Os mapeamentos existentes serão exibidos como links com rel='webAddressMapping'. Por exemplo, no exemplo acima, há três webAddressMappings que apontam para o site http://sites.google.com/site/myOtherTestSite.

Modificar mapeamentos de endereços da Web

Observação: todas as operações GET/POST/PUT 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 serão considerados ao atualizar/remover mapeamentos (PUT) de uma entrada.

Para adicionar, atualizar ou excluir um mapeamento, basta especificar, alterar ou remover o link ao criar novos sites ou atualizar os metadados de um site. O parâmetro with-mappings=true precisa ser incluído no URI do feed de site. Observação: para atualizar os mapeamentos de endereço, você precisa ser um administrador do site ou do domínio, no caso de um site hospedado pelo G Suite.

Por exemplo, a solicitação abaixo atualiza o mapeamento http://www.mysitemapping.com para http://www.my-new-sitemapping.com e remove o http://www.mysitemapping2.com deixando o link fora da entrada:

SiteEntry entry = client.getEntry(new URL("https://sites.google.com/feeds/site/site/siteName?with-mappings=true"), SiteEntry.class);

// Modify mappings (remove all mappings, add some of them again, add modified mappings)
entry.removeLinks(SitesLink.Rel.WEBADDRESSMAPPING, Link.Type.HTML);
entry.addLink(SitesLink.Rel.WEBADDRESSMAPPING, Link.Type.HTML, "http://www.my-new-sitemapping.com");

// Update the entry with the mappings.
entry.update();

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

Voltar ao início

Feed de atividades

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

Para consultar o feed de atividades, envie um GET HTTP ao URL do feed de atividades:

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

No cliente Java, use a classe ActivityFeed para retornar objetos ActivityEntry:

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

public void getActivityFeed() throws IOException, ServiceException {
  ActivityFeed activityFeed = client.getFeed(new URL(buildActivityFeedUrl()), ActivityFeed.class);
  for (BaseActivityEntry<?> entry : activityFeed.getEntries()){
    System.out.println(entry.getSummary().getPlainText());
    System.out.println(" revisions link: " + entry.getRevisionLink().getHref());
  }
}

Observação: o acesso a esse feed requer que você seja um colaborador ou proprietário do site. Seu cliente deve autenticar usando um token gclid, OAuth ou ChromeVox. Consulte Como autenticar no serviço do Google Sites.

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, em seguida, busca o feed de revisão para a primeira entrada de conteúdo:

ContentFeed contentFeed = client.getFeed(new URL(buildContentFeedUrl()), ContentFeed.class);
URL revisionFeedUrl = new URL(contentFeed.getEntries().get(0).getRevisionLink().getHref()); // use first entry

public void getRevisionFeed(String revisionFeedUrl) throws IOException, ServiceException {
  RevisionFeed revisionFeed = client.getFeed(revisionFeedUrl, RevisionFeed.class);
  for (BaseContentEntry<?> entry : revisionFeed.getEntries()){
    System.out.println(entry.getTitle().getPlainText());
    System.out.println(" updated: " + entry.getUpdated().toUiString() + " by " +
        entry.getAuthors().get(0).getEmail());
    System.out.println(" revision #: " + entry.getRevision().getValue());
  }
}

Observação:o acesso a esse feed requer que você seja um colaborador ou proprietário do site. Seu cliente deve autenticar usando um token gclid, OAuth ou ChromeVox. Consulte Como autenticar no serviço do Google Sites.

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 HTTP GET para o URL do feed de conteúdo:

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

Parâmetro de feed	Descrição
`site`	"`site`" ou o domínio do seu domínio hospedado do G Suite (por exemplo, `example.com`).
`siteName`	O nome do espaço Web do seu site, encontrado no URL do site (por exemplo, `mySite`).

Exemplo de busca do feed de conteúdo:

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

ContentFeed contentFeed = client.getFeed(new URL(buildContentFeedUrl()), ContentFeed.class);

O contentFeed resultante é um objeto ContentFeed que contém a resposta do servidor. Cada entrada de contentFeed representa uma página ou um item diferente no site do usuário. O ContentFeed vai conter diferentes tipos de objetos, todos herdados de BaseContentEntry: ListItemEntry, ListPageEntry, AttachmentEntry, WebAttachmentEntry, FileCabinetPageEntry, AnnouncementsPageEntry, AnnouncementEntry, WebPageEntry, CommentEntry.

Veja um exemplo de listagem dos diferentes tipos de entradas em um ContentFeed. Cada tipo de entrada contém propriedades diferentes, mas nem todas são mostradas aqui.

public String getContentBlob(BaseContentEntry<?> entry) {
 return ((XhtmlTextConstruct) entry.getTextContent().getContent()).getXhtml().getBlob();
}

// Extracts an entry's numeric ID.
private String getEntryId(String selfLink) {
  return selfLink.substring(selfLink.lastIndexOf("/") + 1);
}

public void printContentEntries(ContentFeed contentFeed) {
  System.out.println("Listing all WebPageEntry:");
  for (WebPageEntry entry : contentFeed.getEntries(WebPageEntry.class)) {
    System.out.println(" title: " + entry.getTitle().getPlainText());
    System.out.println(" id: " + getEntryId(entry));
    if (entry.getParentLink() != null) {
      System.out.println(" parent id: " + getEntryId(entry.getParentLink().getHref()));
    }
    System.out.println(" author: " + entry.getAuthors().get(0).getEmail());
    System.out.println(" content: " + getContentBlob(entry));
  }

  System.out.println("Listing all ListPageEntry:");
  for (ListPageEntry entry : contentFeed.getEntries(ListPageEntry.class)) {
    System.out.println(" title: " + entry.getTitle().getPlainText());
    System.out.println(" id: " + getEntryId(entry));
    for (Column col : entry.getData().getColumns()) {
      System.out.print(" [" + col.getIndex() + "] " + col.getName() + "\t");
    }
  }

  for (ListItemEntry entry : contentFeed.getEntries(ListItemEntry.class)) {
    for (Field field : entry.getFields()) {
      System.out.print(" [" + field.getIndex() + "] " + field.getValue() + "\t");
    }
    System.out.println("\n");
  }

  System.out.println("Listing all FileCabinetPageEntry:");
  for (FileCabinetPageEntry entry : contentFeed.getEntries(FileCabinetPageEntry.class)) {
    System.out.println(" title: " + entry.getTitle().getPlainText());
    System.out.println(" id: " + getEntryId(entry));
    System.out.println(" content: " + getContentBlob(entry));
  }

  System.out.println("Listing all CommentEntry:");
  for (CommentEntry entry : contentFeed.getEntries(CommentEntry.class)) {
    System.out.println(" in-reply-to: " + entry.getInReplyTo().toString());
    System.out.println(" content: " + getContentBlob(entry));
  }

  System.out.println("Listing all AnnouncementsPageEntry:");
  for (AnnouncementsPageEntry entry : contentFeed.getEntries(AnnouncementsPageEntry.class)) {
    System.out.println(" title: " + entry.getTitle().getPlainText());
    System.out.println(" id: " + getEntryId(entry));
    System.out.println(" content: " + getContentBlob(entry));
  }

  System.out.println("Listing all AnnouncementEntry:");
  for (AnnouncementEntry entry : contentFeed.getEntries(AnnouncementEntry.class)) {
    System.out.println(" title: " + entry.getTitle().getPlainText());
    System.out.println(" id: " + getEntryId(entry));
    if (entry.getParentLink() != null) {
      System.out.println(" parent id: " + getEntryId(entry.getParentLink().getHref()));
    }
    System.out.println(" draft?: " + entry.isDraft());
    System.out.println(" content: " + getContentBlob(entry));
  }

  System.out.println("Listing all AttachmentEntry:");
  for (AttachmentEntry entry : contentFeed.getEntries(AttachmentEntry.class)) {
    System.out.println(" title: " + entry.getTitle().getPlainText());
    System.out.println(" id: " + getEntryId(entry));
    if (entry.getParentLink() != null) {
      System.out.println(" parent id: " + getEntryId(entry.getParentLink().getHref()));
    }
    if (entry.getSummary() != null) {
      System.out.println(" description: " + entry.getSummary().getPlainText());
    }
    System.out.println(" revision: " + entry.getRevision().getValue());
    MediaContent content = (MediaContent) entry.getContent();
    System.out.println(" src: " + content.getUri());
    System.out.println(" content type: " + content.getMimeType().getMediaType());
  }

  System.out.println("Listing all WebAttachmentEntry:");
  for (WebAttachmentEntry entry : contentFeed.getEntries(WebAttachmentEntry.class)) {
    System.out.println(" title: " + entry.getTitle().getPlainText());
    System.out.println(" id: " + getEntryId(entry));
    if (entry.getParentLink() != null) {
      System.out.println(" parent id: " + getEntryId(entry.getParentLink().getHref()));
    }
    if (entry.getSummary() != null) {
      System.out.println(" description: " + entry.getSummary().getPlainText());
    }
    System.out.println(" src: " + ((MediaContent) entry.getContent()).getUri());
  }
}

Observação:o feed pode ou não exigir autenticação, dependendo das permissões de compartilhamento do site. Se o site não for público, o seu cliente deverá fazer a autenticação usando um token EDGE, OAuth ou gclid. Consulte Como autenticar no serviço do Google Sites.

Exemplos de consulta de feed de conteúdo

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

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

Como recuperar tipos de entrada específicos

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

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

Para retornar mais de um tipo de entrada, separe cada kind com ",". Este exemplo retorna entradas filecabinet e listpage:

URL url = new URL(buildContentFeedUrl() + "?kind=filecabinet,listpage");
ContentFeed contentFeed = client.getFeed(url, ContentFeed.class);
for (FileCabinetPageEntry entry : contentFeed.getEntries(FileCabinetPageEntry.class)) {
  System.out.println(" title: " + entry.getTitle().getPlainText());
}
for (ListPageEntry entry : contentFeed.getEntries(ListPageEntry.class)) {
  System.out.println(" title: " + entry.getTitle().getPlainText());
}

Como recuperar uma página por caminho

Se você souber o caminho relativo de uma página no site Google, poderá usar o parâmetro path para buscar essa página específica. Este exemplo retornaria a página localizada em http://sites.google.com/site/siteName/path/to/the/page:

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

Como recuperar todas as entradas em uma página pai

Se você conhece o ID de entrada de conteúdo de uma página (por exemplo, "1234567890" no exemplo abaixo), é possível usar o parâmetro parent para buscar todas as entradas filhas (se houver):

ContentQuery query = new ContentQuery(new URL(buildContentFeedUrl()));
query.setParent("1234567890");
ContentFeed contentFeed = client.getFeed(query, ContentFeed.class);

Para parâmetros adicionais, consulte o Guia de referência.

Voltar ao início

Criação de conteúdo

Observação:antes de criar conteúdo para um site, verifique se você configurou o site no cliente.
client.site = "siteName";

Para criar conteúdo novo (páginas da Web, de listas, de arquivos, de avisos etc.), envie um POST de HTTP para o feed de conteúdo:

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

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

Criar novos itens / páginas

Este exemplo cria um novo webpage no nível superior do site, inclui um código HTML para o corpo da página e define o título do cabeçalho como "Novo título da página da Web":

private void setContentBlob(BaseContentEntry<?> entry, String pageContent) {
  XmlBlob xml = new XmlBlob();
  xml.setBlob(pageContent);
  entry.setContent(new XhtmlTextConstruct(xml));
}

public WebPageEntry createWebPage(String title, String content)
    throws MalformedURLException, IOException, ServiceException {
  WebPageEntry entry = new WebPageEntry();
  entry.setTitle(new PlainTextConstruct(title));

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

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

WebPageEntry createdEntry = createWebPage("New Webpage Title", "<b>HTML content</b>");
System.out.println("Created! View at " + createdEntry.getHtmlLink().getHref());

Se a solicitação for bem-sucedida, createdEntry terá uma cópia da entrada criada no servidor.

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

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

Este exemplo cria uma nova página filecabinet com o cabeçalho "Armazenamento de arquivos", mas cria a página no URL http://sites.google.com/site/siteName/files (em vez de http://sites.google.com/site/siteName/file-storage) especificando o elemento <sites:pageName>.

public FileCabinetPageEntry createFileCabinetPage(String title, String content, String customPageName)
    throws MalformedURLException, IOException, ServiceException {
  FileCabinetPageEntry entry = new FileCabinetPageEntry();
  entry.setTitle(new PlainTextConstruct(title));

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

  entry.setPageName(new PageName(customPageName)); // Upload to a custom page path

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

FileCabinetPageEntry createdEntry = createFileCabinetPage("File Storage", "<b>HTML content</b>", "files");
System.out.println("Created! View at " + createdEntry.getHtmlLink().getHref());

O servidor usa as seguintes regras de precedência para nomear o caminho do URL de uma página:

<sites:pageName>, se presente. Precisa atender a a-z, A-Z, 0-9, -, _.
<atom:title>, não poderá ser nulo se pageName não estiver presente. A normalização consiste em cortar e recolher o espaço em branco para "-" e remover os caracteres que não correspondem a a-z, A-Z, 0-9, -, _.

Como criar subpáginas

Para criar subpáginas (filhos) em uma página pai, é necessário definir o link pai na entrada. O atributo href do link para o self link do nó pai.

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

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

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

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

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

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

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

Modelos da página

Como criar modelos de página

O processo para criar um modelo de página é igual a criar novos itens/páginas e criar subpáginas.A diferença é a adição de category com o termo e o rótulo definidos como "http://schemas.google.com/g/2005#template" e "template", respectivamente.

Neste exemplo, criamos um novo modelo webpage.

// The template webpage entry.
WebPageEntry entry = new WebPageEntry();

// Set title and content.
entry.setTitle(new PlainTextConstruct("Page template title"));
XmlBlob xml = new XmlBlob();
xml.setBlob("Content for page template");
entry.setContent(new XhtmlTextConstruct(xml));

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

// Insert the template webpage entry.
WebPageEntry createdEntry = client.insert(new URL("https://sites.google.com/feeds/content/site/siteName"), entry);

Como criar páginas com base em um modelo

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

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

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

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

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

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

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

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

Observação: mesmo que um modelo defina um <category>, ainda é necessário incluir um na entrada. Além disso, se você incluir um elemento <content>, o servidor o rejeitará.

Como fazer upload de arquivos

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

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

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

Todos os tipos de anexo precisam ser enviados para uma página principal. Portanto, defina um link pai no objeto AttachmentEntry ou WebAttachmentEntry que você está tentando enviar. Consulte Como criar subpáginas para mais informações.

Fazendo upload dos anexos

Este exemplo faz o upload de um arquivo PDF para a primeira FileCabinetPageEntry encontrada no feed de conteúdo do usuário. O anexo é criado com o título "Getting Started" e uma descrição (opcional) como "HR package".

MimetypesFileTypeMap mediaTypes = new MimetypesFileTypeMap();
mediaTypes.addMimeTypes("application/msword doc");
mediaTypes.addMimeTypes("application/vnd.ms-excel xls");
mediaTypes.addMimeTypes("application/pdf pdf");
mediaTypes.addMimeTypes("text/richtext rtx");
// ... See a more complete list of mime types in the SitesHelper.java

public AttachmentEntry uploadAttachment(File file, BasePageEntry<?> parentPage,
    String title, String description) throws IOException, ServiceException {
  AttachmentEntry newAttachment = new AttachmentEntry();
  newAttachment.setMediaSource(new MediaFileSource(file, mediaTypes.getContentType(file)));
  newAttachment.setTitle(new PlainTextConstruct(title));
  newAttachment.setSummary(new PlainTextConstruct(description));
  newAttachment.addLink(SitesLink.Rel.PARENT, Link.Type.ATOM, parentPage.getSelfLink().getHref());

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

ContentFeed contentFeed = client.getFeed(new URL(buildContentFeedUrl() + "?kind=filecabinet"), ContentFeed.class);
FileCabinetPageEntry parentPage = contentFeed.getEntries(FileCabinetPageEntry.class).get(0);

AttachmentEntry attachment = uploadAttachment(
    new File("/path/to/your/file.pdf"), parentPage, "Getting Started", "HR packet");
System.out.println("Uploaded!");

Se o upload der certo, attachment terá uma cópia da entrada de anexo criada.

Fazer upload de um anexo para uma pasta

Para fazer upload de um anexo para uma pasta existente em um FileCabinetPageEntry, inclua uma categoria com o atributo "term" definido como o nome da pasta. Por exemplo, adicione esta linha em uploadAttachment():

newAttachment.getCategories().add(new Category("http://schemas.google.com/sites/2008#folder", "FolderName"));

Anexos da Web

Anexos da Web são tipos especiais de anexos. Em essência, eles são links para outros arquivos na Web que você pode adicionar às suas listagens de arquivo. Esse recurso é análogo ao método de upload "Adicionar arquivo por URL" na interface do Google Sites.

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

Este exemplo cria um WebAttachmentEntry no primeiro FileCabinetPageEntry encontrado no feed de conteúdo do usuário. O título e a descrição (opcional) são definidos como "GoogleLogo" e "nice cores", respectivamente.

public WebAttachmentEntry uploadWebAttachment(String contentUrl, FileCabinetPageEntry filecabinet,
    String title, String description) throws MalformedURLException, IOException, ServiceException {
  MediaContent content = new MediaContent();
  content.setUri(contentUrl);

  WebAttachmentEntry webAttachment = new WebAttachmentEntry();
  webAttachment.setTitle(new PlainTextConstruct(title));
  webAttachment.setSummary(new PlainTextConstruct(description));
  webAttachment.setContent(content);
  webAttachment.addLink(SitesLink.Rel.PARENT, Link.Type.ATOM,
      filecabinet.getSelfLink().getHref());

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

ContentFeed contentFeed = client.getFeed(new URL(buildContentFeedUrl() + "?kind=filecabinet"), ContentFeed.class);
FileCabinetPageEntry parentPage = contentFeed.getEntries(FileCabinetPageEntry.class).get(0);

WebAttachmentEntry webAttachment =
    uploadWebAttachment("http://www.google.com/images/logo.gif", parentPage, "Google's Logo", "nice colors");
System.out.println("Web attachment created!");

O POST cria um link no arquivo do usuário apontando para a imagem em "http://www.google.com/images/logo.gif".

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 enviará uma solicitação HTTP PUT para o link edit da entrada.

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

O título é modificado para "Título atualizado"
O conteúdo HTML da página foi atualizado para "<p>Conteúdo HTML atualizado</p>"
O primeiro cabeçalho de coluna da lista é alterado para "Proprietário"

ContentFeed contentFeed = client.getFeed(
    new URL(buildContentFeedUrl() + "?kind=listpage"), ContentFeed.class);
ListPageEntry listPage = contentFeed.getEntries(ListPageEntry.class).get(0); // Update first list page found

// Update title
listPage.setTitle(new PlainTextConstruct("Updated Title"));

// Update HTML content
XmlBlob xml = new XmlBlob();
xml.setBlob("<p>Updated HTML Content</p>");
listPage.setContent(new XhtmlTextConstruct(xml));

// Change first column's heading
listPage.getData().getColumns().get(0).setName("Owner");

// listPage.setPageName(new PageName("new-page-path"));  // You can also change the page's URL path

ListPageEntry updatedEntry = listPage.update();

System.out.println("ListPage updated!");

Atualizando o conteúdo do arquivo anexo

Para AttachmentEntry, você também pode atualizar o conteúdo definindo o MediaSource da entrada e, em seguida, usando o método updateMedia(boolean) da entrada.

Este exemplo vai atualizar o conteúdo de um anexo:

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

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

Atualizar metadados e conteúdo do anexo

É possível atualizar os metadados e o conteúdo de um anexo na mesma chamada usando o método updateMedia(). Se for possível atualizar apenas o conteúdo do arquivo, os metadados ou ambos.

Este exemplo altera o título do anexo para "Novo título", atualiza sua descrição e substitui o conteúdo do arquivo por um novo arquivo .zip. Como a solicitação inclui novo conteúdo de arquivo, o updateMedia() do AttachmentEntry é usado.

public AttachmentEntry updateAttachment(AttachmentEntry entry, File newFile, String newTitle, String newDescription)
    throws IOException, ServiceException  {
  // See Uploading Attachments for the definition of mediaTypes.
  entry.setMediaSource(new MediaFileSource(newFile, mediaTypes.getContentType(newFile)));
  entry.setTitle(new PlainTextConstruct(newTitle));
  entry.setSummary(new PlainTextConstruct(newDescription));

  return entry.updateMedia(true);
}

ContentFeed contentFeed = client.getFeed(
    new URL(buildContentFeedUrl() + "?kind=attachment&max-results=1"), ContentFeed.class);
AttachmentEntry attachment = contentFeed.getEntries(AttachmentEntry.class).get(0); // Update first attachment found

AttachmentEntry updatedAttachment = updateAttachment(attachment, new File("/path/to/file.zip"), "New Title", "better stuff");

Voltar ao início

Exclusão de conteúdo

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

entry.delete();

Você também pode usar o método delete() da classe de serviço transmitindo o link edit da entrada e o valor da ETag:

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

Se a entrada tiver sido excluída, o servidor responderá com um 200 OK HTTP.

Voltar ao início

Fazendo o download de anexos

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

Este exemplo faz o download do primeiro AttachmentEntry encontrado no feed de conteúdo do usuário para o diretório "/path/to/save/file/":

private void downloadFile(String downloadUrl, String fullFilePath) throws IOException, ServiceException {
  System.out.println("Downloading file from: " + downloadUrl);

  MediaContent mc = new MediaContent();
  mc.setUri(downloadUrl);
  MediaSource ms = service.getMedia(mc);

  InputStream inStream = null;
  FileOutputStream outStream = null;

  try {
    inStream = ms.getInputStream();
    outStream = new FileOutputStream(fullFilePath);

    int c;
    while ((c = inStream.read()) != -1) {
      outStream.write(c);
    }
  } finally {
    if (inStream != null) {
      inStream.close();
    }
    if (outStream != null) {
      outStream.flush();
      outStream.close();
    }
  }
}

public void downloadAttachment(AttachmentEntry entry, String directory) throws IOException, ServiceException {
  String url = ((OutOfLineContent) entry.getContent()).getUri();
  downloadFile(url, directory + entry.getTitle().getPlainText()); // Use entry's title for the save filename
}

ContentFeed contentFeed = client.getFeed(
    new URL(buildContentFeedUrl() + "?kind=attachment&max-results=1"), ContentFeed.class);

downloadAttachment(contentFeed.getEntries(AttachmentEntry.class).get(0), "/path/to/save/file/");
System.out.println("Downloaded.");

Voltar ao início

Feed da ACL

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

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

Papéis

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

reader: um visualizador (equivalente ao acesso somente leitura).
writer: um colaborador (equivalente ao acesso de leitura/gravação).
owner: normalmente, o administrador do site (equivalente ao acesso de leitura/gravação).

Escopos

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

user: um valor de endereço de e-mail, por exemplo, "user@gmail.com".
group: um endereço de e-mail do Grupo do Google, por exemplo, "grupo@dominio.com".
domínio: um nome de domínio do G Suite, por exemplo, "domínio.com".
default: há apenas um escopo possível do tipo "default", que não tem valor (por exemplo, <gAcl:scope type="default">). Esse escopo específico controla o acesso que qualquer usuário tem por padrão em um site público.

Observação: os domínios não podem ter um valor gAcl:role definido como acesso de "proprietário". Eles só podem ser leitores ou gravadores.

Como recuperar o feed da ACL

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

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

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

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

getAclFeed('my-site-name');

Se você estiver trabalhando com entradas no SiteFeed, cada SiteEntry conterá um link para seu feed da ACL. Por exemplo, este snippet busca o feed "ACL" de um SiteEntry:

String aclLink = siteEntry.getLink(SitesAclFeedLink.Rel.ACCESS_CONTROL_LIST, Link.Type.ATOM).getHref();
AclFeed aclFeed = client.getFeed(new URL(aclLink), AclFeed.class);

Como compartilhar um site

Observação: algumas ACLs de compartilhamento só serão possíveis se o domínio estiver configurado para conceder essas permissões. Por exemplo, se o compartilhamento fora do domínio para domínios do G Suite estiver ativado etc.

Para compartilhar um site Google usando a API, seu cliente precisa criar um novo AclEntry e POST no servidor.

Confira um exemplo que adiciona "user@example.com" como um reader no site:

AclRole role = new AclRole("reader");
AclScope scope = new AclScope(AclScope.Type.USER, "user@example.com");
AclEntry aclEntry = addAclRole(role, scope, entry);

public AclEntry addAclRole(AclRole role, AclScope scope, SiteEntry siteEntry)
    throws IOException, MalformedURLException, ServiceException  {
  AclEntry aclEntry = new AclEntry();
  aclEntry.setRole(role);
  aclEntry.setScope(scope);

  Link aclLink = siteEntry.getLink(SitesAclFeedLink.Rel.ACCESS_CONTROL_LIST, Link.Type.ATOM);
  return client.insert(new URL(aclLink.getHref()), aclEntry);
}

Consulte a seção Visão geral do feed da ACL para ver os possíveis valores AclScope e AclRoles.

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

De forma semelhante ao compartilhamento de um site com um único usuário, o compartilhamento pode ser feito em um grupo do Google ou domínio do G Suite.

Como compartilhar com um endereço de e-mail de grupo:

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

Compartilhamento com um domínio inteiro:

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

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

Modificar permissões de compartilhamento

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

Este exemplo modifica nosso exemplo anterior de aclEntry da seção Como compartilhar um site, atualizando "user@example.com" para ser um writer (colaborador):

aclEntry.setRole(new AclRole("writer"));
AclEntry updatedAclEntry = aclEntry.update();

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

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

Removendo permissões de compartilhamento

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

aclEntry.delete();

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

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

Voltar ao início

Temas especiais

Como recuperar um feed ou uma entrada novamente

Se você quiser recuperar um feed ou uma entrada recuperada anteriormente, poderá melhorar a eficiência solicitando que o servidor envie a lista ou a entrada somente se ela tiver sido alterada desde a última vez em que você a recuperou.

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

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

String feedUrl = "https://sites.google.com/feeds/content/site/siteName/123456789";
WebPageEntry entry = client.getEntry(new URL(feedUrl), WebPageEntry.class, "\"GVQHSARDQyp7ImBq\"");

Quando o servidor recebe essa solicitação, ele verifica se o item solicitado tem a mesma ETag que você especificou. Se as ETags corresponderem, o item não foi alterado e o servidor retornará uma exceção NotModifiedException HTTP 304.

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

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

Voltar ao início

Guia da linguagem Java

Público-alvo

Como começar

Instalar a biblioteca

Como executar o aplicativo de amostra

Como iniciar seu próprio projeto

Como autenticar na API Sites clássico

AuthSub para aplicativos da web

Solicitar um token de uso único

Como fazer upgrade para um token de sessão

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

Como revogar um token de sessão

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

Como buscar um token de solicitação

Como autorizar um token de solicitação

Como fazer upgrade para um token de acesso

GCLID para aplicativos instalados/móveis

Feed do site

Sites de listagem

Criação de sites

Como copiar um site

Como atualizar os metadados de um site

Mapeamentos de endereços da Web

Como buscar os mapeamentos de endereços da Web de um site

Modificar mapeamentos de endereços da Web

Feed de atividades

Feed de revisão

Feed de conteúdo

Como recuperar o feed de conteúdo

Exemplos de consulta de feed de conteúdo

Como recuperar tipos de entrada específicos

Como recuperar uma página por caminho

Como recuperar todas as entradas em uma página pai

Criação de conteúdo

Criar novos itens / páginas

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

Como criar subpáginas

Modelos da página

Como criar modelos de página

Como criar páginas com base em um modelo

Como fazer upload de arquivos

Fazendo upload dos anexos

Fazer upload de um anexo para uma pasta

Anexos da Web

Atualizar conteúdo

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

Atualizando o conteúdo do arquivo anexo

Atualizar metadados e conteúdo do anexo

Exclusão de conteúdo

Fazendo o download de anexos

Feed da ACL

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

Papéis

Escopos

Como recuperar o feed da ACL

Como compartilhar um site

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

Modificar permissões de compartilhamento

Removendo permissões de compartilhamento

Temas especiais

Como recuperar um feed ou uma entrada novamente