Guía del lenguaje Java

Importante: Este documento se redactó antes de 2012. Las opciones de autenticación que se describen en este documento (OAuth 1.0, AuthSub y ClientLogin) dejaron de estar disponibles de forma oficial a partir del 20 de abril de 2012. Te recomendamos que migres a OAuth 2.0 lo antes posible.

La API de datos de Google Sites permite que las aplicaciones cliente accedan a contenido de un sitio de Google, lo publiquen y lo modifiquen. Tu aplicación cliente también puede solicitar una lista de actividades recientes, recuperar el historial de revisiones y descargar archivos adjuntos.

Además de proporcionar información sobre las funciones de la API de Sites Data, esta guía ofrece ejemplos para interactuar con la API con la biblioteca cliente de Java. Si necesitas ayuda para configurar la biblioteca cliente, consulta Cómo comenzar a usar la biblioteca cliente de Google Data para Java. Si te interesa obtener más información sobre el protocolo subyacente que usa la biblioteca cliente de Java para interactuar con la API de Sites clásica, consulta la guía de protocolos.

Público

Este documento está dirigido a desarrolladores que deseen escribir aplicaciones cliente que interactúen con Google Sites a través de la biblioteca cliente de Java de datos de Google.

Cómo comenzar

Sitios de Google usa Cuentas de Google o cuentas de G Suite para la autenticación. Si ya tienes una cuenta, no tienes que hacer nada más. De lo contrario, puedes crear una cuenta nueva.

Cómo instalar la biblioteca

Si necesitas ayuda para configurar e instalar la biblioteca cliente, consulta Cómo comenzar a usar la biblioteca cliente de Google Data para Java. Si usas Eclipse, ese artículo también explica cómo configurar tu proyecto con el complemento de Eclipse de las API de datos de Google. Esto es lo que necesitas para comenzar:

1. Instala Java 1.5 o una versión posterior
2. Descarga la biblioteca cliente (la versión más reciente de gdata-src.java.zip).
3. Descarga la lista de dependencias
4. Descarga las aplicaciones de muestra (la versión más reciente de gdata-samples.java.zip).

Después de instalar el archivo .jars, deberás incluir lo siguiente en tu proyecto:

1. java/lib/gdata-sites-2.0.jar: La versión 2.0 aquí está destinada a la versión 1.4 de la API de Sites clásica.
2. java/lib/gdata-core-1.0.jar
3. java/lib/gdata-client-1.0.jar
4. java/lib/gdata-spreadsheet-3.0.jar (si trabajas con páginas o elementos de lista)

Además, asegúrate de incluir los archivos JAR de dependencia (gdata-media-1.0.jar, mail.jar y google-collect....jar).

Ejecuta la aplicación de muestra

Una aplicación de ejemplo funcional completa se encuentra en el subdirectorio /java/sample/sites de la descarga de gdata-samples.java.zip. La fuente también está disponible en /trunk/java/sample/sites/ en el repositorio de SVN al que se puede acceder desde la pestaña Fuente. SitesDemo.java permite al usuario realizar una serie de operaciones que demuestran cómo usar la API de Sites clásica.

Ten en cuenta que deberás incluir java/sample/util/lib/sample-util.jar para ejecutar la muestra.

Cómo iniciar tu propio proyecto

Sugerencia: Consulta el artículo Cómo usar Eclipse con las APIs de Google Data para realizar una configuración rápida con nuestro complemento de Eclipse.

Según las necesidades de tu aplicación, necesitarás varias importaciones. Te recomendamos que comiences con las siguientes importaciones:

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.*;

A continuación, también deberás configurar un objeto SitesService, que representa una conexión de cliente a la API de Sites clásica:

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

El argumento applicationName debe seguir el formato company-applicationname-version. Este parámetro se usa para registrar información.

Nota: En el resto de esta guía, se supone que creaste un SitesService en la variable client.

Autenticación en la API de Sites clásica

La biblioteca cliente de Java se puede usar para trabajar con feeds públicos o privados. La API de Sites Data proporciona acceso a feeds privados y públicos, según los permisos de Sites y la operación que intentas realizar. Por ejemplo, es posible que puedas leer el feed de contenido de un sitio público, pero no realizar actualizaciones, lo que requeriría un cliente autenticado. Esto se puede hacer a través de la autenticación de nombre de usuario y contraseña de ClientLogin, AuthSub o OAuth.

Consulta la Descripción general de la autenticación de las APIs de Google Data para obtener más información sobre AuthSub, OAuth y ClientLogin.

Nota: La API admite SSL (HTTPS). Si usas AuthSub/OAuth, asegúrate de especificar un permiso de https://sites.google.com/feeds/ para solicitar feeds a través de SSL. Ten en cuenta que, en el caso de los dominios de G Suite, la API respeta la configuración "Require SSL" en el panel de control administrativo. Puedes forzar que todas las solicitudes de la API se realicen a través de HTTPS llamando a client.useSsl();.

AuthSub para aplicaciones web

Las aplicaciones cliente que necesiten autenticar a sus usuarios en Cuentas de Google deben usar la autenticación de AuthSub para aplicaciones web. El operador no necesita acceso al nombre de usuario ni a la contraseña del usuario de Google Sites. Solo se requiere un token de AuthSub.

import com.google.gdata.client.*;

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

import com.google.gdata.client.*;

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

OAuth para aplicaciones web o instaladas/para dispositivos móviles

OAuth se puede usar como alternativa a AuthSub y está diseñado para aplicaciones web. OAuth es similar al uso del modo seguro y registrado de AuthSub en que todas las solicitudes de datos deben estar firmadas digitalmente y debes registrar tu dominio.

ClientLogin para aplicaciones instaladas/móviles

Las aplicaciones instaladas o para dispositivos móviles que necesiten autenticar a sus usuarios en las Cuentas de Google deben usar ClientLogin. En la primera ejecución, tu aplicación le solicita al usuario su nombre de usuario o contraseña. En las solicitudes posteriores, se hace referencia a un token de autenticación.

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

Volver al principio

Feed del sitio

El feed del sitio se puede usar para crear una lista de los sitios de Google que un usuario posee o para los que tiene permisos de lectura. También se puede usar para modificar el nombre de un sitio existente. En el caso de los dominios de G Suite, también se puede usar para crear o copiar un sitio completo.

Enumera sitios

Para consultar el feed del sitio, envía un GET HTTP a la URL del feed del sitio:

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

En el cliente Java, puedes usar las clases SiteFeed y SiteEntry para trabajar con el feed del sitio:

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("");
  }
}

El fragmento anterior imprime el título, el nombre y el tema del sitio. Hay otros métodos get disponibles para acceder a propiedades adicionales en el feed.

Creación de sitios nuevos

Nota: Esta función solo está disponible para los dominios de G Suite.

Para aprovisionar sitios nuevos, crea un SiteEntry nuevo y llama al método insert() del cliente en el feed de sitios.

En este ejemplo, se crea un sitio nuevo con el tema “slate” (configuración opcional) y se proporciona el nombre del sitio (obligatorio) y la descripción (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");

La solicitud anterior crearía un sitio nuevo en el dominio de G Suite example.com. Por lo tanto, la URL del sitio sería https://sites.google.com/a/example.com/mi-título-del-sitio.

Si el sitio se crea correctamente, el servidor responderá con un objeto SiteEntry, propagado con elementos que el servidor agregó: un vínculo al sitio, un vínculo al feed de ACL del sitio, el nombre del sitio, el título, el resumen, etcétera.

Cómo copiar un sitio

Nota: Esta función solo está disponible para los dominios de G Suite.

Copiar un sitio es similar a crear uno nuevo. La diferencia es que debes configurar un vínculo en tu SiteEntry nuevo que incluya el vínculo propio del sitio que deseas duplicar. Este es un ejemplo de cómo duplicar el sitio creado en la sección Cómo crear sitios nuevos:

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);

Puntos importantes:

• Solo se pueden copiar los sitios y las plantillas de sitios que pertenecen al usuario autenticado.
• También se puede copiar una plantilla de sitio. Un sitio es una plantilla si está marcada la opción "Publicar este sitio como una plantilla" en la página de configuración de Google Sites.
• Puedes copiar un sitio de otro dominio, siempre y cuando aparezcas como propietario en el sitio de origen.

Actualiza los metadatos de un sitio

Para cambiar el nombre de un sitio o el tema, la etiqueta de categoría o el resumen, primero debes recuperar el objeto SiteEntry que contiene el sitio en cuestión, modificar una o más propiedades y, luego, llamar al método update() de SiteEntry. En este ejemplo, se modifica el tema del sitio anterior y se le cambia el nombre:

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();

Asignaciones de direcciones web

Las asignaciones de direcciones web permiten que los usuarios de Sites asignen sus propios dominios a un sitio de Google. Por ejemplo, se puede usar http://www.mydomainsite.com en lugar de http://sites.google.com/a/domain.com/mysite. Según dónde se aloje tu sitio, puedes modificar manualmente las asignaciones de direcciones web de un sitio. Consulta nuestro artículo del Centro de ayuda para obtener más información.

Recupera las asignaciones de direcciones web de un sitio

Para mostrar las asignaciones de direcciones web de un sitio, recupera la entrada o el feed del sitio con el 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());
  }
}

Las asignaciones existentes se mostrarán como link con rel='webAddressMapping'. Por ejemplo, en el ejemplo anterior, hay tres webAddressMapping que apuntan al sitio http://sites.google.com/site/myOtherTestSite.

Modifica las asignaciones de direcciones web

Nota: Todas las operaciones GET/POST/PUT deben especificar el parámetro with-mappings=true cuando trabajan con asignaciones de direcciones web. Si no se incluye el parámetro, no se mostrarán webAddressMapping en las entradas del sitio (GET) ni se considerarán cuando se actualicen o quiten (PUT) las asignaciones de una entrada.

Para agregar, actualizar o borrar una asignación, simplemente especifica, cambia o quita ese vínculo cuando crees sitios nuevos o actualices los metadatos de un sitio. El parámetro with-mappings=true se debe incluir en el URI del feed del sitio. Nota: Para actualizar las asignaciones de direcciones, debes ser administrador del sitio o administrador de dominio en el caso de un sitio alojado en G Suite.

Por ejemplo, la siguiente solicitud actualiza la asignación de http://www.mysitemapping.com a http://www.my-new-sitemapping.com y quita el http://www.mysitemapping2.com dejando el vínculo fuera de la 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();

Ten en cuenta que las asignaciones de direcciones web también se pueden especificar al momento de crear o copiar un sitio.

Volver al principio

Feed de actividad

Para recuperar la actividad reciente (cambios) de un sitio, recupera el feed de actividad. Cada entrada del feed de actividad contiene información sobre un cambio que se realizó en el sitio.

Para consultar el feed de actividad, envía un GET HTTP a la URL del feed de actividad:

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

En el cliente Java, usa la clase ActivityFeed para mostrar 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());
  }
}

Nota: Para acceder a este feed, debes ser colaborador o propietario del sitio. Tu cliente debe autenticarse con un token de AuthSub, OAuth o ClientLogin. Consulta Cómo autenticar el servicio de Sites.

Volver al principio

Feed de revisión

Para recuperar el historial de revisión de cualquier entrada de contenido, envía un GET HTTP al vínculo de revisión de la entrada:

https://sites.google.com/feeds/revision/site/siteName/CONTENT_ENTRY_ID

En este ejemplo, se consulta el feed de contenido y, luego, se recupera el feed de revisión de la primera entrada de contenido:

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());
  }
}

Nota: Para acceder a este feed, debes ser colaborador o propietario del sitio. Tu cliente debe autenticarse con un token de AuthSub, OAuth o ClientLogin. Consulta Cómo autenticarse en el servicio de Sites.

Volver al principio

Canal de contenido

Cómo recuperar el feed de contenido

En el feed de contenido, se muestra el contenido más reciente de un sitio. Para acceder a él, envía un GET HTTP a la URL del feed de contenido:

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

Ejemplo de recuperación del canal de contenido:

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);

El contentFeed resultante es un objeto ContentFeed que contiene la respuesta del servidor. Cada entrada de contentFeed representa una página o un elemento diferente dentro del sitio del usuario. ContentFeed contendrá diferentes tipos de objetos, todos heredados de BaseContentEntry: ListItemEntry, ListPageEntry, AttachmentEntry, WebAttachmentEntry, FileCabinetPageEntry, AnnouncementsPageEntry, AnnouncementEntry, WebPageEntry, CommentEntry.

Este es un ejemplo de cómo enumerar los diferentes tipos de entradas en un ContentFeed. Cada tipo de entrada contiene diferentes propiedades, pero no todas se imprimen aquí.

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());
  }
}

Nota: Este feed puede requerir o no autenticación, según los permisos de uso compartido del sitio. Si el Sitio no es público, su cliente debe autenticarse mediante un token AuthSub, OAuth o ClientLogin. Consulta Cómo autenticarse en el servicio de Sites.

Ejemplos de consulta del canal de contenido

Puedes buscar en el feed de contenido con algunos de los parámetros de consulta estándar de la API de Google Data y los específicos de la API de Sites clásica. Para obtener información más detallada y una lista completa de los parámetros admitidos, consulta la Guía de referencia.

Nota: En los ejemplos de esta sección, se usa el método buildContentFeedUrl() en Cómo recuperar el feed de contenido.

Cómo recuperar tipos de entrada específicos

Para recuperar solo un tipo de entrada en particular, usa el parámetro kind. Este ejemplo muestra solo las entradas de 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 mostrar más de un tipo de entrada, separa cada kind con una ",". En este ejemplo, se muestran entradas filecabinet y 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());
}

Recupera una página por ruta de acceso

Si conoces la ruta de acceso relativa de una página dentro del sitio de Google, puedes usar el parámetro path para recuperar esa página en particular. Este ejemplo mostraría la página ubicada en 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());
}

Cómo recuperar todas las entradas de una página superior

Si conoces el ID de entrada de contenido de una página (p.ej., "1234567890" en el siguiente ejemplo), puedes usar el parámetro parent para recuperar todas sus entradas secundarias (si las hubiera):

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

Para ver parámetros adicionales, consulta la Guía de referencia.

Volver al principio

Creación de contenido

Nota: Antes de crear contenido para un sitio, asegúrate de haberlo configurado en el cliente.
client.site = "siteName";

Para crear contenido nuevo (páginas web, páginas de listas, páginas de carpetas de archivos, páginas de anuncios, etcétera), envía un POST HTTP al feed de contenido:

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

Para obtener una lista de los tipos de nodos de asistencia, consulta el parámetro kind en la Guía de referencia.

Creación de nuevos elementos o páginas

En este ejemplo, se crea un webpage nuevo debajo del nivel superior del sitio, se incluye XHTML para el cuerpo de la página y se establece el título del encabezado en "Nuevo título de la página 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());

Si la solicitud se realiza correctamente, createdEntry contendrá una copia de la entrada creada en el servidor.

Creación de elementos o páginas en rutas de URL personalizadas

De forma predeterminada, el ejemplo anterior se crearía en la URL http://sites.google.com/site/siteName/new-webpage-title y tendría un encabezado de página que diga “Título de la página web nueva”. Es decir, el <atom:title> se normaliza a new-webpage-title para la URL. Para personalizar la ruta de URL de una página, puedes configurar el elemento <sites:pageName>.

En este ejemplo, se crea una página filecabinet nueva con el encabezado "Almacenamiento de archivos", pero se crea la página en la URL http://sites.google.com/site/siteName/files (en lugar de http://sites.google.com/site/siteName/file-storage) especificando el 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());

El servidor usa las siguientes reglas de prioridad para asignar un nombre a la ruta de URL de una página:

1. <sites:pageName>, si está presente Debe satisfacer a-z, A-Z, 0-9, -, _.
2. <atom:title> no debe ser nulo si pageName no está presente. La normalización consiste en recortar y contraer los espacios en blanco a “-” y quitar los caracteres que no coinciden con a-z, A-Z, 0-9, -, _.

Crear subpáginas

Para crear subpáginas (secundarias) en una página principal, debes establecer el vínculo principal en la entrada. El atributo href del vínculo al vínculo propio del nodo superior

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());

En el ejemplo anterior, se crea un announcement nuevo debajo de la primera página de anuncios que se encuentra en el feed de contenido del usuario. El título del anuncio es "Fiesta" y el contenido es "Mi casa, este fin de semana".

Plantillas de páginas

Creando plantillas de páginas

El proceso para crear una plantilla de página es el mismo que el de crear nuevos elementos o páginas y crear subpáginas.La diferencia es la adición de category con el término y la etiqueta establecidos en “http://schemas.google.com/g/2005#template” y “template”, respectivamente.

En este ejemplo, se crea una nueva plantilla de 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);

Cómo crear páginas a partir de una plantilla

Al igual que cuando creas plantillas de páginas, puedes crear una instancia de una página nueva a partir de una plantilla si incluyes un <link> con rel='http://schemas.google.com/sites/2008#template' que dirija al vínculo propio de una plantilla de página.

En este ejemplo, se crea una nueva plantilla de filecabinet y, luego, se crea una instancia de una nueva página de filecabinet a partir de esa plantilla.

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);

Nota: A pesar de que una plantilla que define un <category>, aún se requiere incluir una en tu entrada. Además, ten en cuenta que, si incluyes un elemento <content>, el servidor lo rechazará.

Cómo subir archivos

Al igual que en Google Sites, la API admite la carga de archivos adjuntos en la página del archivo o en una página superior.

Para subir un archivo adjunto a un elemento superior, envía una solicitud HTTP POST a la URL del feed de contenido:

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

Todos los tipos de archivos adjuntos deben subirse a una página superior. Por lo tanto, estableces un vínculo superior en el objeto AttachmentEntry o WebAttachmentEntry que intentas subir. Consulta Cómo crear subpáginas para obtener más información.

Subiendo archivos adjuntos

En este ejemplo, se sube un archivo PDF al primer FileCabinetPageEntry que se encuentra en el feed de contenido del usuario. El archivo adjunto se crea con el título "Primeros pasos" y una descripción (opcional) que dice "Paquete de recursos humanos".

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!");

Si la carga se realiza correctamente, attachment contendrá una copia de la entrada de archivo adjunto creada.

Cómo subir un archivo adjunto a una carpeta

Para subir un archivo adjunto a una carpeta existente en un FileCabinetPageEntry, incluye una categoría con el atributo "term" establecido en el nombre de la carpeta. Por ejemplo, agrega esta línea en uploadAttachment():

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

Adjuntos web

Los adjuntos web son tipos especiales de archivos adjuntos. En esencia, son vínculos a otros archivos en la Web que puedes agregar a las fichas de tu archivo. Esta función es análoga al método de carga "Agregar archivo mediante URL" en la IU de Google Sites.

Nota: Los archivos adjuntos web solo se pueden crear en un archivo de carpetas. No se pueden subir a otros tipos de páginas.

En este ejemplo, se crea un WebAttachmentEntry debajo del primer FileCabinetPageEntry que se encuentra en el feed de contenido del usuario. Su título y descripción (opcional) se establecen en "GoogleLogo" y "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!");

El POST crea un vínculo en el archivo del usuario que dirige a la imagen en "http://www.google.com/images/logo.gif".

Volver al principio

Actualización de contenido

Actualiza los metadatos o el contenido HTML de una página

Los metadatos (título, pageName, etc.) y el contenido de la página de cualquier tipo de BaseContentEntry se pueden editar con el método update() de la entrada. Eso enviará una solicitud PUT HTTP al vínculo edit de la entrada.

A continuación, se muestra un ejemplo de cómo actualizar un ListPageEntry con los siguientes cambios:

• Se modifica el título a "Título actualizado".
• El contenido HTML de la página se actualiza a "<p>Actualizado el contenido HTML</p>".
• El encabezado de la primera columna de la lista cambia a "Propietario".

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!");

Actualiza el contenido de un archivo adjunto

Para AttachmentEntry, también puedes actualizar el contenido si configuras el MediaSource de la entrada y, luego, usas el método updateMedia(boolean) de la entrada.

En este ejemplo, se actualizará el contenido de un archivo adjunto existente:

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

En el ejemplo, se envía una solicitud PUT HTTP al vínculo edit-media de la entrada. El AttachmentEntry que se muestra contendrá el contenido actualizado.

Actualiza los metadatos y el contenido de los archivos adjuntos

Puedes actualizar los metadatos de un archivo adjunto y su contenido en la misma llamada con el método updateMedia(). Si puedes actualizar solo el contenido del archivo, los metadatos o ambos.

En este ejemplo, se cambia el título del archivo adjunto a "Título nuevo", se actualiza la descripción y se reemplaza el contenido del archivo por un archivo ZIP nuevo. Dado que la solicitud contiene contenido de archivo nuevo, se usa el updateMedia() de AttachmentEntry.

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");

Volver al principio

Cómo borrar contenido

Para quitar una página o un elemento de un sitio de Google, primero recupera la entrada de contenido y, luego, llama al delete() de la entrada.

entry.delete();

También puedes usar el método delete() de la clase de servicio. Para ello, pasa el vínculo edit de la entrada y el valor de ETag:

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

Si la entrada se borró correctamente, el servidor responde con un 200 OK HTTP.

Volver al principio

Cómo descargar archivos adjuntos

Para descargar un AttachmentEntry, envía una solicitud HTTP GET al vínculo src del contenido de la entrada.

En este ejemplo, se descarga el primer AttachmentEntry que se encuentra en el feed de contenido del usuario en el directorio “/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.");

Volver al principio

Feed de ACL

Descripción general de los permisos de uso compartido (LCA)

Cada entrada de LCA en el feed de LCA representa un rol de acceso de una entidad en particular, ya sea un usuario, un grupo de usuarios, un dominio o el acceso predeterminado (que es un sitio público). Solo se mostrarán las entradas de las entidades con acceso explícito. Se mostrará una entrada para cada dirección de correo electrónico en el panel "Personas con acceso" en la pantalla de uso compartido de la IU de Google Sites. Por lo tanto, no se mostrarán los administradores de dominio, aunque tengan acceso implícito a un sitio.

Funciones

El elemento de rol representa un nivel de acceso que puede tener una entidad. El elemento gAcl:role tiene cuatro valores posibles:

• reader: Un usuario con permiso de lectura (equivalente al acceso de solo lectura).
• writer: Un colaborador (equivalente al acceso de lectura y escritura).
• owner: Por lo general, el administrador del sitio (equivalente al acceso de lectura y escritura).

Permisos

El elemento de alcance representa la entidad que tiene este nivel de acceso. Existen cuatro tipos posibles del elemento gAcl:scope:

• user: un valor de dirección de correo electrónico, p. ej., "usuario@gmail.com".
• group: Es una dirección de correo electrónico de Grupos de Google, p. ej., "grupo@domain.com".
• domain: Es un nombre de dominio de G Suite, p. ej., "domain.com".
• default: Solo hay un alcance posible de tipo "default", que no tiene ningún valor (p. ej., <gAcl:scope type="default">). Este alcance en particular controla el acceso que cualquier usuario tiene de forma predeterminada en un sitio público.

Nota: Los dominios no pueden tener un valor de gAcl:role configurado en el acceso de "propietario", solo pueden ser lectores o escritores.

Recupera el feed de LCA

Las clases AclFeed y AclEntry se pueden usar para controlar los permisos de uso compartido de un sitio y se pueden recuperar con el método getFeed() de la clase de servicio.

En el siguiente ejemplo, se recupera el feed de LCA de un sitio determinado y se imprimen los permisos 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');

Si trabajas con entradas en SiteFeed, cada SiteEntry contiene un vínculo a su feed de LCA. Por ejemplo, este fragmento recupera el feed de LCA de una SiteEntry:

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

Compartir un sitio

Nota: Ciertas LCA de uso compartido solo pueden ser posibles si el dominio está configurado para permitir dichos permisos (p.ej., si el uso compartido fuera del dominio para dominios de G Suite está habilitado, etcétera).

Para compartir un sitio de Google con la API, tu cliente debe crear un AclEntry nuevo y POSTarlo al servidor.

Este es un ejemplo que agrega "user@example.com" como reader en el sitio:

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);
}

Consulta la sección Descripción general del feed de LCA para conocer los posibles valores de AclScope y AclRoles.

Uso compartido a nivel de grupos y dominios

Al igual que compartir un sitio con un solo usuario, puedes compartir un sitio en un grupo de Google o un dominio de G Suite.

Si compartes contenido con una dirección de correo electrónico del grupo:

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

Uso compartido con un dominio completo:

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

El uso compartido a nivel del dominio solo se admite para los dominios de G Suite y únicamente para el dominio en el que se aloja el sitio. Por ejemplo, http://sites.google.com/a/dominio1.com/sitioA solo puede compartir todo el sitio con dominio1.com, no con dominio2.com. Los sitios que no están alojados en un dominio de G Suite (p.ej., http://sites.google.com/sitio/sitioB) no pueden invitar dominios.

Modificación de los permisos de uso compartido

Para un permiso de uso compartido existente en un sitio, primero recupera el AclEntry en cuestión, modifica el permiso como desees y, luego, llama al método update() de AclEntry para modificar la LCA en el servidor.

En este ejemplo, se modifica nuestro ejemplo anterior de aclEntry de la sección Cómo compartir un sitio, actualizando "user@example.com" para que sea un 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 obtener más información sobre las ETag, consulta la guía de referencia de las APIs de datos de Google.

Eliminación de permisos de uso compartido

Para quitar un permiso de uso compartido, primero recupera el AclEntry y, luego, llama a su método delete():

aclEntry.delete();

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

Para obtener más información sobre las ETags, consulta la guía de referencia de las APIs de Google Data.

Volver al principio

Temas especiales

Cómo volver a recuperar un feed o una entrada

Si deseas recuperar un feed o una entrada que ya recuperaste, puedes mejorar la eficiencia si le indicas al servidor que envíe la lista o la entrada solo si cambió desde la última vez que la recuperaste.

Para hacer este tipo de recuperación condicional, los métodos getFeed() y getEntry() proporcionan un argumento adicional que acepta un valor de ETag o un objeto DateTime para el encabezado If-Modified-Since. Puedes acceder a la etiqueta de etag de una entrada desde entry.getEtag().

En este ejemplo, se realiza una recuperación condicional para una entrada de página web de contenido:

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

Cuando el servidor recibe esta solicitud, verifica si el elemento que solicitaste tiene la misma ETag que la que especificaste. Si los ETags coinciden, el elemento no cambió, y el servidor muestra una excepción HTTP 304 NotModifiedException.

Si las ETags no coinciden, significa que el elemento se modificó desde la última vez que lo solicitaste y el servidor lo muestra.

Para obtener más información sobre las ETags, consulta la guía de referencia de las APIs de Google Data.

Volver al principio