Descontinuada: a API Sites foi descontinuada e pode parar de funcionar a qualquer momento. A API Sites só acessa o Sites clássico. A API Sites não consegue acessar a versão recriada do Sites, que foi lançada em 22 de novembro de 2016.

Guia da linguagem Java

Importante:este documento foi escrito antes de 2012. As opções de autenticação descritas neste documento (OAuth 1.0, AuthSub e ClientLogin) 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 Google Sites Data permite que aplicativos cliente acessem, publiquem e modifiquem conteúdo em um site Google. O aplicativo cliente também pode solicitar uma lista de atividades recentes, buscar o histórico de revisões e baixar anexos.

Além de fornecer informações básicas sobre os recursos da API Sites Data, este guia oferece exemplos de interação com a API usando a biblioteca de cliente Java. Para ajuda na configuração da biblioteca de cliente, consulte Como começar a usar a biblioteca de cliente Java do Google Data. Se você quiser entender melhor o protocolo usado pela biblioteca de cliente Java para interagir com a API Sites clássico, consulte o guia de protocolo.

Público-alvo

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

Primeiros passos

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

Instalar a biblioteca

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

Instale 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)
Baixar a 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 projeto:

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

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

Como executar o aplicativo de amostra

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

É necessário incluir java/sample/util/lib/sample-util.jar para executar a amostra.

Como iniciar seu próprio projeto

Dica: consulte o artigo Usar o Eclipse com as APIs de dados do Google para uma configuração rápida com nosso plug-in do Eclipse.

Dependendo das necessidades do seu aplicativo, você vai 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á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 oferece acesso a feeds particulares e públicos, 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 fazer atualizações nele, o que exigiria um cliente autenticado. Isso pode ser feito com a autenticação de nome de usuário/senha do ClientLogin, o AuthSub ou o OAuth.

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

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

AuthSub para aplicativos da web

A autenticação AuthSub para aplicativos da Web deve ser usada por aplicativos cliente 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 AuthSub é necessário.

Confira instruções para incorporar o AuthSub ao seu aplicativo da Web

Solicitar um token de uso único

Quando o usuário acessa o aplicativo pela primeira vez, ele precisa se autenticar. Normalmente, os desenvolvedores imprimem um texto e um link que direciona o usuário para a página de aprovação do AuthSub para autenticar o usuário e solicitar acesso aos documentos dele. A biblioteca de cliente Java do Google Data 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 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 AuthSubRequest):

o URL next, para onde 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 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/móveis

O OAuth pode ser usado como alternativa ao AuthSub e é destinado a aplicativos da Web. O OAuth é semelhante ao uso do modo seguro e registrado do AuthSub, já que todas as solicitações de dados precisam ser assinadas digitalmente e você precisa registrar seu domínio.

Ver 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.

Autorizar um token de solicitação

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

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 para dispositivos móveis que precisam autenticar os usuários em Contas do Google. Na primeira execução, o aplicativo solicita o nome de usuário/senha do usuário. Em solicitações subsequentes, um token de autenticação é referenciado.

Confira instruções para incorporar o ClientLogin ao 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 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 uso posterior. Não é necessário pedir a senha do usuário a 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 em aplicativos Java, consulte Como usar o ClientLogin com as bibliotecas de cliente da API Google Data.

Voltar ao início

Feed de site

O feed de sites pode ser usado para listar os Sites Google que um usuário tem ou para os quais 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, também é possível usar o recurso para criar e/ou copiar um site inteiro.

Sites de listagem

Para consultar o feed do site, envie um HTTP GET 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 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 propriedades adicionais no feed.

Criar novos sites

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

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

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

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/my-site-title.

Se o site for criado, o servidor vai responder com um objeto SiteEntry preenchido com elementos adicionados pelo servidor: um link para o site, um link para o feed de lista de controle de acesso (ACL, na sigla em inglês) do site, o nome do site, o título, o resumo e assim por diante.

Copiar um site

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

Copiar um site é semelhante a criar um novo. A diferença é que você precisa definir um link no novo SiteEntry que inclua o link próprio do site a ser duplicado. Confira um exemplo de como duplicar o site criado na seção Criar 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 de propriedade do usuário autenticado podem ser copiados.
Um modelo de site também pode ser copiado. 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, desde que esteja listado como proprietário no site de origem.

Atualizar os metadados de um site

Para renomear um site, mudar o tema, a tag de categoria ou o resumo, primeiro busque o SiteEntry que contém o site em questão, modifique uma ou mais propriedades e chame 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 de onde seu site está hospedado, é possível modificar manualmente os mapeamentos de endereços da Web de um site. Consulte o 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ços da Web de um site, busque a entrada/feed do site com o parâmetro with-mappings=true:

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

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

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

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 em entradas de site (GET) nem considerados ao atualizar/remover (PUT) mapeamentos de uma entrada.

Para adicionar, atualizar ou excluir um mapeamento, basta especificar, mudar 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ços, 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 de http://www.mysitemapping.com para http://www.my-new-sitemapping.com e remove http://www.mysitemapping2.com ao deixar o link fora da entrada:

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

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

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

Observação: os mapeamentos de endereços da Web também podem ser especificados ao criar/copiar um site.

Voltar ao início

Feed de atividades

Para buscar a atividade recente (mudanças) de um site, busque 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 HTTP GET para o URL do feed de atividades:

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

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

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

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

Observação: para acessar esse feed, você precisa ser um colaborador ou proprietário do site. O cliente precisa se autenticar usando um token AuthSub, OAuth ou ClientLogin. Consulte Autenticação no serviço Sites.

Voltar ao início

Feed de revisão

Para buscar o histórico de revisões de qualquer entrada de conteúdo, envie um HTTP GET 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 da primeira entrada de conteúdo:

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

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

Observação:para acessar esse feed, você precisa ser colaborador ou proprietário do site. O cliente precisa se autenticar usando um token AuthSub, OAuth ou ClientLogin. Consulte Autenticação no serviço Sites.

Voltar ao início

Feed de conteúdo

Recuperar o feed de conteúdo

O feed de conteúdo lista o conteúdo mais recente de um site. Ele pode ser acessado enviando um 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 na 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.

Confira um exemplo de como listar os diferentes tipos de entradas em um ContentFeed. Cada tipo de entrada contém propriedades diferentes, mas nem todas são impressas aqui.

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

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

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

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

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

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

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

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

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

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

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

Observação:esse feed pode ou não exigir autenticação, dependendo das permissões de compartilhamento do site. Se o site não for público, o cliente precisará fazer a autenticação usando um token AuthSub, OAuth ou ClientLogin. Consulte Autenticação no serviço Sites.

Exemplos de consultas de feed de conteúdo

É possível pesquisar o feed de conteúdo usando alguns dos parâmetros de consulta padrão da API Google Data e aqueles específicos da API Sites clássico. Para mais informações 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 entradas 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 uma vírgula. Este exemplo retorna entradas filecabinet e listpage:

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

Como recuperar uma página por caminho

Se você souber o caminho relativo de uma página no Google Sites, use 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 principal

Se você souber o ID da entrada de conteúdo de uma página (por exemplo, "1234567890" no exemplo abaixo), use 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 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ê definiu o site no cliente.
client.site = "siteName";

Para criar novos conteúdos (páginas da Web, páginas de lista, páginas de arquivo, páginas de anúncio etc.), envie um HTTP POST para o feed de conteúdo:

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

Para ver uma lista de tipos de nós compatíveis, 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 pouco de XHTML para o corpo da página e define o título do cabeçalho como "New WebPage Title":

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

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

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

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

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

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

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 cabeçalho de página "New Webpage Title". Ou seja, o <atom:title> é normalizado para new-webpage-title no URL. Para personalizar o caminho do URL de uma página, defina o elemento <sites:pageName>.

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

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

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

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

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

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

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

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

Como criar subpáginas

Para criar subpáginas (filhas) em uma página principal, defina o link principal na entrada. O atributo href do link para o link próprio 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 anúncios encontrada no feed de conteúdo do usuário. O título do anúncio é "Festa!!" e o conteúdo é "Na minha casa, neste fim de semana".

Modelos da página

Como criar modelos de página

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

Este exemplo cria um novo modelo webpage.

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

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

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

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

Criar páginas com base em um modelo

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

Este exemplo cria um novo modelo filecabinet e depois cria uma nova página filecabinet com base nesse modelo.

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

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

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

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

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

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

Observação: apesar de um modelo definir um <category>, ainda é necessário incluir um na sua entrada. Além disso, se você incluir um elemento <content>, o servidor vai rejeitá-lo.

Fazer upload de arquivos

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

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

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

Todos os tipos de anexos precisam ser enviados para uma página principal. Portanto, defina um link de parentesco 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 upload de um arquivo PDF para o primeiro FileCabinetPageEntry encontrado no feed de conteúdo do usuário. O anexo é criado com o título "Como 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 vai conter uma cópia da entrada de anexo criada.

Fazer upload de um anexo para uma pasta

Para fazer upload de um anexo em uma pasta 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

Os anexos da Web são tipos especiais de anexos. Basicamente, são links para outros arquivos na Web que você pode adicionar às listas do seu gaveteiro. Esse recurso é semelhante ao método de upload "Adicionar arquivo por URL" na interface do Google Sites.

Observação: os anexos da Web só podem ser criados em um arquivo. Não é possível fazer upload delas para outros tipos de páginas.

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

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

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

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

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

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

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

Voltar ao início

Atualizando conteúdo

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

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

Confira abaixo um exemplo de 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 é atualizado para "<p>Updated HTML Content</p>"
O cabeçalho da primeira coluna da lista muda 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 de anexo

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 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 ao link edit-media da entrada. O AttachmentEntry retornado vai conter o conteúdo atualizado.

Atualizar metadados e conteúdo de anexos

É 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 muda o título do anexo para "New Title", atualiza a descrição e substitui o conteúdo do arquivo por um novo arquivo .zip. Como a solicitação contém um novo conteúdo de arquivo, o updateMedia() do AttachmentEntry é usado.

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

  return entry.updateMedia(true);
}

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

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

Voltar ao início

Excluir conteúdo

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

entry.delete();

Você também pode usar o método delete() da classe de serviço transmitindo o link edit e o valor de 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 HTTP 200 OK.

Voltar ao início

Baixando anexos

Para baixar um AttachmentEntry, envie uma solicitação HTTP GET ao link content src da entrada.

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

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

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

  InputStream inStream = null;
  FileOutputStream outStream = null;

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

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

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

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

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

Voltar ao início

Feed de ACL

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

Cada entrada no feed de 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 só serão mostradas para entidades com acesso explícito. Uma entrada será mostrada para cada endereço de e-mail no painel "Pessoas com acesso" na tela de compartilhamento da interface do Google Sites. Assim, os administradores de domínio não vão aparecer, mesmo que tenham acesso implícito a um site.

Papéis

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

leitor: um leitor (equivalente ao acesso somente leitura).
writer: um colaborador (equivalente ao acesso de leitura/gravação).
Proprietário: geralmente o administrador do site (equivalente ao acesso de leitura/gravação).

Escopos

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

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

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

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 ACLs 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 vai conter um link para o feed de ACL. Por exemplo, este snippet busca o feed de 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ó são possíveis se o domínio estiver configurado para permitir essas permissões (por exemplo, se o compartilhamento fora do domínio para domínios do G Suite estiver ativado etc.).

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

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

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

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

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

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

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

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

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

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

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, http://sites.google.com/a/domain1.com/siteA só pode compartilhar o site inteiro com domain1.com, não com domain2.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.

Como modificar permissões de compartilhamento

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

Este exemplo modifica o exemplo anterior de aclEntry da seção 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.

Remover permissões de compartilhamento

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

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

Recuperar um feed ou uma entrada novamente

Se você quiser recuperar um feed ou uma entrada que já recuperou antes, melhore a eficiência pedindo ao servidor para enviar a lista ou a entrada somente se ela tiver mudado 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 o 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 ETag especificada. Se as ETags forem iguais, o item não terá sido alterado, e o servidor vai retornar uma exceção HTTP 304 NotModifiedException.

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

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

Voltar ao início

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

Público-alvo

Primeiros passos

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/móveis

Como buscar um token de solicitação

Autorizar um token de solicitação

Fazer upgrade para um token de acesso

ClientLogin para aplicativos instalados/móveis

Feed de site

Sites de listagem

Criar novos sites

Copiar um site

Atualizar os metadados de um site

Mapeamentos de endereços da Web

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

Como modificar mapeamentos de endereços da Web

Feed de atividades

Feed de revisão

Feed de conteúdo

Recuperar o feed de conteúdo

Exemplos de consultas de feed de conteúdo

Como recuperar tipos de entradas específicos

Como recuperar uma página por caminho

Como recuperar todas as entradas em uma página principal

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

Criar páginas com base em um modelo

Fazer upload de arquivos

Fazendo upload dos anexos

Fazer upload de um anexo para uma pasta

Anexos da Web

Atualizando conteúdo

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

Atualizando o conteúdo do arquivo de anexo

Atualizar metadados e conteúdo de anexos

Excluir conteúdo

Baixando anexos

Feed de ACL

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

Papéis

Escopos

Como recuperar o feed da ACL

Compartilhar um site

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

Como modificar permissões de compartilhamento

Remover permissões de compartilhamento

Temas especiais

Recuperar um feed ou uma entrada novamente

Guia da linguagem Java