Guía del lenguaje Java

Importante: Este documento se redactó antes de 2012. Las opciones de Auth descritos en este documento (OAuth 1.0, AuthSub y ClientLogin) se se dio de baja oficialmente desde el 20 de abril de 2012 y ya no están disponibles. Te recomendamos que migres 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 la actividad reciente, recuperar el historial de revisión y descargar archivos adjuntos.

Además de proporcionar información general sobre las capacidades de la API de Sites Data, en esta guía se proporcionan ejemplos de cómo interactuar con la API. con la biblioteca cliente de Java. Para obtener ayuda con la configuración de la biblioteca cliente, consulta Cómo comenzar a usar la biblioteca cliente de Java de datos de Google. Si te interesa sobre el protocolo subyacente que usa la biblioteca cliente de Java para interactuar con la API de la versión clásica de Sites, consulta el guía del protocolo.

Público

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

Cómo comenzar

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

Cómo instalar la biblioteca

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

1. Instala Java 1.5 o superior.
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 está diseñada para la versión 1.4 de la API de la versión clásica de Sites.
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

Hay una aplicación de ejemplo que funciona correctamente 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 varias operaciones que demuestran cómo usar la API de la versión clásica de Sites.

Nota: Deberás incluir java/sample/util/lib/sample-util.jar para ejecutar la muestra.

Cómo comenzar tu propio proyecto

Sugerencia: Consulta el artículo Cómo usar Eclipse con las APIs de datos de Google para obtener 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 la versión clásica de Sites:

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

El argumento applicationName debe seguir este formato: company-applicationname-version. Este parámetro se usa con fines de registro.

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

Autentícate en la API de la versión clásica de Sites

La biblioteca cliente Java se puede utilizar para trabajar con feeds públicos o privados. La API de Sites Data brinda acceso a redes privadas en función de los permisos de Sites y de la operación que quieras realizar. Por ejemplo, puedes leer el canal de contenido de un sitio público sin actualizarlo (lo que requeriría un cliente autenticado). Esto se puede hacer Autenticación con nombre de usuario y contraseña de ClientLogin, OAuth o AuthSub.

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

Sugerencia: La API admite SSL (HTTPS). Si utilizas AuthSub/OAuth, asegúrate de especificar un alcance de https://sites.google.com/feeds/ para solicitar feeds a través de SSL. Además, ten en cuenta que para dominios de G Suite, la capa "Require SSL" del panel de control de administrador se respeta en la API. Puedes forzar todo Solicitudes a la API para usar HTTPS llamando a client.useSsl();

AuthSub para aplicaciones web

La autenticación de AuthSub para aplicaciones web debe usarse en las aplicaciones cliente que necesitan para autenticar a sus usuarios en Cuentas de Google. El operador no necesita acceder al nombre de usuario ni a la contraseña del usuario de Google Sites; solo se necesita un El token de AuthSub es obligatorio.

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 o 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 el sentido de que todas las solicitudes de datos se deben firmar digitalmente y debes registrar tu dominio.

ClientLogin para aplicaciones instaladas/móviles

ClientLogin debe ser utilizado por aplicaciones instaladas o móviles que necesiten para autenticar a sus usuarios en Cuentas de Google. En la primera ejecución, tu aplicación le solicita al usuario su nombre de usuario y contraseña. En 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. Para los dominios de G Suite, también se puede usar para crear o copiar un todo el sitio.

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 de 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 insert() en el feed del sitio.

En este ejemplo se crea un sitio totalmente nuevo con el tema "slate" (configuración opcional) y 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");

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

Si el sitio se crea correctamente, el servidor responderá con SiteEntry. objeto, completado con elementos agregados por el servidor: un vínculo al sitio, un vínculo al feed de LCA del sitio, el nombre del sitio, el título, el resumen, etc.

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 establecer en tu nuevo SiteEntry que incluya el vínculo propio del sitio que se debe duplicar. A continuación, se muestra un ejemplo de cómo duplicar un 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 para sitios. Un sitio es una plantilla si el botón "Publicar este sitio como plantilla" esté marcado en la página de configuración de Google Sites.
• Puedes copiar un sitio de otro dominio, siempre que aparezcas como propietario en el sitio de origen.

Actualiza los metadatos de un sitio

Para cambiar el nombre de un sitio o modificar el tema, la etiqueta de categoría o el resumen, primero deberás recuperar SiteEntry que contenga el sitio en cuestión. modifica una o más propiedades y, luego, llama 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 a los usuarios de Sites asignar sus propios dominios a un sitio de Google. Por ejemplo, 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 un las asignaciones de direcciones web de tu sitio. Para obtener más información, consulte el artículo de nuestro Centro de ayuda.

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 elementos webAddressMapping que apuntan al sitio http://sites.google.com/site/myOtherTestSite

Cómo modificar las asignaciones de direcciones web

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

Para agregar, actualizar o borrar una asignación, simplemente especifica, cambia o quita el vínculo al crear nuevos sitios. actualizar los metadatos de un sitio. El parámetro with-mappings=true debe incluirse en el URI del feed del sitio. Nota: Para actualizar las asignaciones de direcciones, debes ser administrador del sitio o 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 de un sitio (cambios), recupera el feed de actividad. Cada entrada de la el feed de actividad contiene información sobre un cambio realizado 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 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, a continuación, se obtiene el feed de revisiones para 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 AuthSub, OAuth o ClientLogin. Consulta Cómo autenticar el servicio de Sites.

Volver al principio

Canal de contenido

Cómo recuperar el canal de contenido

El canal de contenido muestra el contenido más reciente de un sitio. Se puede acceder enviando 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);

La 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 y CommentEntry.

A continuación, se muestra 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: Es posible que el feed requiera 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 Autenticación en el servicio de Sites.

Ejemplos de consulta del canal de contenido

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

Nota: Los ejemplos de esta sección utilizan 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 específico, usa el parámetro kind. En este ejemplo, se muestran solo 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 mostrar más de un tipo de entrada, separa cada kind con una “,”. En este ejemplo, se muestra filecabinet y listpage entradas:

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 relativa de una página dentro de Google Sites, puedes usar el parámetro path para recuperar esa página en particular. Este ejemplo devolverí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());
}

Recuperar todas las entradas de una página principal

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

Se puede crear contenido nuevo (páginas web, páginas de listas, páginas de gabinete de archivos, páginas de anuncios, etc.) enviando un POST HTTP. al canal de contenido:

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

Para obtener una lista de los tipos de nodos de compatibilidad, 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, que incluye XHTML para el cuerpo de la página. y 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 bajo la URL. http://sites.google.com/site/siteName/new-webpage-title y tener un encabezado de página con el título "Nuevo título de la página web". Es decir, <atom:title> se normaliza en 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 nueva página de filecabinet con un encabezado de "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 precedencia para asignar un nombre a la ruta de URL de una página:

1. <sites:pageName>, si está presente. Debe cumplir con a-z, A-Z, 0-9, -, _.
2. <atom:title> no debe ser nulo si pageName no está presente. La normalización consiste en cortar + contraer los espacios en blanco a “-” y quita los caracteres que no coincidan 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 superior en la entrada. El atributo href del vínculo al del 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 nuevo objeto announcement en la primera página de anuncios que se encuentra en el canal de contenido del usuario. El título del anuncio se estableció en "¡Fiesta!". y el contenido, en "Mi lugar, 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 Crea subpáginas. La diferencia es la adición de category con el término y la etiqueta establecidos como “http://schemas.google.com/g/2005#template”. y "template", respectivamente.

En este ejemplo, se crea una plantilla webpage nueva.

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

Crea páginas a partir de una plantilla

Al igual que cuando creas plantillas de páginas, puedes incluir un <link> con rel='http://schemas.google.com/sites/2008#template' para crear una instancia de una página nueva a partir de una plantilla. señalando 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 página de filecabinet nueva a partir de ella.

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 define un <category>, se incluye una en tu aún se requiere una 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 una página de gabinete de archivos o en una página principal.

Para subir un archivo adjunto a un elemento superior, envía una solicitud POST HTTP 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, estableciste un vínculo superior en AttachmentEntry. o WebAttachmentEntry objeto que intentas subir. Consulta Crea 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): 'HR package' [Paquete de RR.HH.]

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 "término". configurado como el nombre de la carpeta. Por ejemplo, agrega esta línea a uploadAttachment():

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

Archivos adjuntos web

Los archivos adjuntos web son tipos especiales de archivos adjuntos. Básicamente son vínculos a otros archivos en la Web. que puedes agregar a tus listas de gabinetes de archivos. Esta función es análoga a "Agregar archivo mediante URL". método de carga en la IU de Google Sites.

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

En este ejemplo, se crea un WebAttachmentEntry en el primer FileCabinetPageEntry que se encuentra en el feed de contenido del usuario. El título y la descripción (opcional) están configurados como “GoogleLogo”. y "colores bonitos", 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 elemento POST crea un vínculo en el gabinete de archivos del usuario que apunta a la imagen en "http://www.google.com/images/logo.gif".

Volver al principio

Actualización de contenido

Actualizar 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 edit de la entrada. enlace.

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>Contenido HTML actualizado</p>”.
• El encabezado de la primera columna de la lista se 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!");

Actualizando el contenido del 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.

Este ejemplo 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 valor devuelto AttachmentEntry incluirá 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. Como la solicitud incluye 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

Eliminación de 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 descargan los primeros AttachmentEntry que se encuentran en el feed de contenido del usuario. al 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 LCA

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 de la sección “Personas con acceso” en la pantalla para compartir de la IU de Google Sites. Por lo tanto, no se mostrarán a 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: Es un lector (equivalente a acceso de solo lectura).
• escritor: Un colaborador (equivalente al acceso de lectura/escritura)
• owner: Por lo general, el administrador del sitio (equivalente al acceso de lectura/escritura)

Permisos

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

• user: un valor de dirección de correo electrónico, p. ej., "usuario@gmail.com".
• group: una dirección de correo electrónico de Grupos de Google, p. ej., "grupo@dominio.com".
• dominio: un nombre de dominio de G Suite, p. ej., "dominio.com".
• default: solo hay un alcance posible del tipo “default”, que no tiene 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 gAcl:role configurado como "propietario" solo pueden ser lectores o escritores.

Recupera el feed de LCA

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

El siguiente ejemplo recupera el feed de LCA para un sitio determinado e imprime 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 estás trabajando con entradas en el 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);

Cómo 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 está habilitado el uso compartido fuera del dominio para dominios de G Suite, etcétera).

Para compartir un Sitio de Google usando la API, tu cliente debe crear un nuevo sitio AclEntry y POST en el servidor.

Este es un ejemplo de “usuario@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 AclScope. y AclRoles.

Uso compartido a nivel del dominio y del grupo

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

Compartir con una dirección de correo electrónico de 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. Sitios que No están alojadas en un dominio de G Suite (p.ej., http://sites.google.com/site/siteB) 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 y modifica el permiso. como desees y, luego, llama al método update() de AclEntry para modificar la LCA en el servidor.

Este ejemplo modifica nuestro ejemplo anterior de aclEntry de la sección Cómo compartir un sitio. actualizando "usuario@example.com" para ser 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 ETag, consulta la guía de referencia de las APIs de datos de Google.

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 indicando que el servidor 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 ETag de una entrada desde entry.getEtag().

En este ejemplo, se realiza una recuperación condicional de 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, comprueba si el elemento que solicitaste tiene la misma ETag que la ETag que especificaste. Si los ETags coinciden, entonces el elemento no ha cambiado, y el servidor devuelve un Se arrojará la excepción NotModifiedException de HTTP 304.

Si los ETag no coinciden, entonces el elemento se modificó desde la última vez que lo solicitaste, y el servidor lo muestra.

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

Volver al principio