El 22 de noviembre de 2016 se lanzó una versión rediseñada de Sites. La API de Sites no puede acceder ni modificar los sitios creados con esta versión, pero puede acceder a la versión clásica de Sites.

Se usó la API de Cloud Translation para traducir esta página.

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) se dieron de baja oficialmente a partir del 20 de abril de 2012 y ya no están disponibles. Te recomendamos que migres a OAuth 2.0 lo antes posible.

La API de datos de Google Sites permite que las aplicaciones cliente accedan, publiquen y modifiquen contenido dentro de un sitio de Google. 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 funciones de la API de Sites Data, en esta guía se proporcionan ejemplos de cómo interactuar con la API a través de la biblioteca cliente de Java. Para obtener ayuda con la configuración de la biblioteca cliente, consulta Comienza a usar la biblioteca cliente de Google Data Java. Si quieres obtener más información 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 la guía de protocolo.

Público

Este documento está dirigido a desarrolladores que deseen escribir aplicaciones cliente que interactúen con Google Sites mediante 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 Google Data Java. Si usas Eclipse, en ese artículo también se 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:

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

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

java/lib/gdata-sites-2.0.jar: Esta versión 2.0 está diseñada para la versión 1.4 de la API de la versión clásica de Sites.
java/lib/gdata-core-1.0.jar
java/lib/gdata-client-1.0.jar
java/lib/gdata-spreadsheet-3.0.jar (si trabaja 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 completa y en funcionamiento en el subdirectorio /java/sample/sites de la descarga 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 le permite al usuario realizar una serie de operaciones que demuestran cómo usar la API de la versión clásica de Sites.

Ten en cuenta que 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. Recomendamos comenzar 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 el siguiente formato: company-applicationname-version. Este parámetro se usa con fines de registro.

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

Autentica en la API de la versión clásica de Sites

La biblioteca cliente de Java se puede usar para trabajar con feeds públicos o privados. La API de datos de Sites proporciona acceso a feeds privados y públicos, en función de los permisos de Sites y la operación que intentes realizar. Por ejemplo, es posible que puedas leer el canal de contenido de un sitio público sin actualizarlo, algo que requeriría un cliente autenticado. Esto se puede hacer a través de la autenticación con el nombre de usuario y contraseña ClientLogin, AuthSub o OAuth.

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

Sugerencia: La API admite SSL (HTTPS). Si usas AuthSub/OAuth, asegúrate de especificar un alcance de https://sites.google.com/feeds/ para solicitar feeds mediante SSL. Además, ten en cuenta que, para los dominios de G Suite, la API respeta la configuración "Exigir SSL" del panel de control administrativo. Puedes llamar a client.useSsl(); para forzar que todas las solicitudes a la API usen HTTPS.

AuthSub para aplicaciones web

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

Consulta las instrucciones para incorporar AuthSub en tu aplicación web

Solicita un token de un solo uso

Cuando el usuario visita tu aplicación por primera vez, debe autenticarse. Por lo general, los desarrolladores imprimen parte del texto y un vínculo que dirige al usuario a la página de aprobación de AuthSub para autenticarlo y solicitar acceso a sus documentos. La biblioteca cliente de Java de datos de Google proporciona una función para generar esta URL. El siguiente código configura un vínculo a la página AuthSubRequest.

import com.google.gdata.client.*;

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

Si quieres autenticar usuarios en tu dominio alojado en G Suite, sigue estos pasos:

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

El método getRequestUrl() usa varios parámetros (correspondientes a los parámetros de consulta que usa el controlador AuthSubRequest):

La URL siguiente: Es la URL a la que Google redireccionará después de que el usuario acceda a su cuenta y le otorgue acceso; http://www.example.com/welcome.jsp en el ejemplo anterior.
El alcance: https://sites.google.com/feeds/ en el ejemplo anterior
un valor booleano para indicar si el token se usará en modo registrado o no; false en el ejemplo anterior
un segundo valor booleano para indicar si el token se intercambiará por un token de sesión o no más adelante; true en el ejemplo anterior

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

OAuth se puede utilizar 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 deben firmarse de manera digital y debes registrar tu dominio.

Consulta las instrucciones para incorporar OAuth en tu aplicación instalada

Recupera un token de solicitud

Consulta Cómo usar OAuth con las bibliotecas cliente de la API de datos de Google.

Autoriza un token de solicitud

Consulta Cómo usar OAuth con las bibliotecas cliente de la API de datos de Google.

Actualiza a un token de acceso

Consulta Cómo usar OAuth con las bibliotecas cliente de la API de datos de Google.

ClientLogin en aplicaciones instaladas o para dispositivos móviles

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

Consulta las instrucciones para incorporar ClientLogin en tu aplicación instalada

Para usar ClientLogin, invoca el método setUserCredentials() del objeto SitesService, que se hereda de GoogleService. Especifica la dirección de correo electrónico y la contraseña del usuario en cuyo nombre tu cliente realiza solicitudes. Por ejemplo:

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

Sugerencia: Cuando tu aplicación haya autenticado con éxito al usuario por primera vez, almacena el token de autenticación en tu base de datos para recuperarlo y usarlo más adelante. No es necesario solicitarle al usuario su contraseña en cada ejecución de tu aplicación. Consulta Recupera un token de autenticación para obtener más información.

Para obtener más información sobre el uso de ClientLogin en tus aplicaciones de Java, consulta el artículo sobre cómo usar ClientLogin con las bibliotecas cliente de la API de datos de Google.

Volver al principio

Feed del sitio

El feed del sitio se puede usar para mostrar los sitios de Google que un usuario posee o para los que tiene permisos de visualización. 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 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 método insert() del cliente en el feed del sitio.

En este ejemplo, se crea un sitio nuevo con el tema "cortinilla de video" (configuración opcional) y se proporcionan 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 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 creó correctamente, el servidor responderá con un objeto SiteEntry, propagado con los elementos que agregó el servidor: un vínculo al sitio, un vínculo al feed de la LCA del sitio, el nombre del sitio, el título, el resumen, etcétera.

Copia un sitio

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

El proceso para copiar un sitio es similar al de crear uno nuevo. La diferencia es que debes configurar un vínculo en tu SiteEntry nuevo que incluya el vínculo propio del sitio para duplicarlo. A continuación, te mostramos 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 parámetro de configuració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, aunque aparezcas como propietario en el sitio de origen.

Actualizar los metadatos de un sitio

Para cambiar el nombre de un sitio o su tema, etiqueta de categoría o resumen, primero deberás recuperar el archivo SiteEntry que contenga 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 a los usuarios de Sites asignar 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 esté alojado tu sitio, puedes modificar manualmente las asignaciones de direcciones web de un sitio. Para obtener más información, consulta el artículo de nuestro Centro de ayuda.

Cómo recuperar las asignaciones de direcciones web de un sitio

Para mostrar las asignaciones de direcciones web de un sitio, recupera la entrada del sitio o el feed 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'. 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 se trabaja con asignaciones de direcciones web. Si el parámetro está ausente, no se mostrarán webAddressMapping en las entradas del sitio (GET) ni se tendrán en cuenta cuando se actualicen o quiten las asignaciones (PUT) de una entrada.

Para agregar, actualizar o borrar una asignación, simplemente especifica, cambia o quita el vínculo cuando crees sitios nuevos o actualices 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 un administrador del sitio o un 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 http://www.mysitemapping2.com si no incluyes el vínculo en 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 (los cambios), puedes obtener 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 HTTP GET a la URL del feed de actividad:

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

En el cliente de 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 se debe autenticar mediante un token AuthSub, OAuth o ClientLogin. Consulta Cómo realizar la autenticación en el servicio de Sites.

Volver al principio

Feed de revisiones

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 canal de contenido y luego se obtiene 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 se debe autenticar mediante un token AuthSub, OAuth o ClientLogin. Consulta Cómo realizar la autenticación en 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 a ella enviando un GET HTTP a la URL del canal de contenido:

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

Parámetro del feed	Descripción
`site`	"`site`" o el dominio de tu dominio alojado en G Suite (p.ej., `example.com`).
`siteName`	Es el nombre del espacio web de tu sitio, que se encuentra en la URL del sitio (p.ej., `mySite`).

Ejemplo de recuperación del feed 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 una lista de los diferentes tipos de entradas en un ContentFeed. Cada tipo de entrada contiene propiedades diferentes, 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 autenticación o no, según los permisos de uso compartido del sitio. Si el Sitio no es público, tu cliente debe autenticarse con un token AuthSub, OAuth o ClientLogin. Consulta Cómo realizar la autenticación en el servicio de Sites.

Ejemplos de consultas de feeds de contenido

Puedes buscar en el feed de contenido con algunos de los parámetros de consulta estándar de la API de datos de Google y aquellos específicos 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: 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 entradas específicos

Para recuperar solo un tipo de entrada en particular, usa el parámetro kind. En este ejemplo, solo se muestran 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 un ",". En este ejemplo, se muestran las 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());
}

Cómo recuperar una página por ruta

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

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 configurarlo en el cliente.
client.site = "siteName";

Puedes crear contenido nuevo (páginas web, páginas de listas, páginas de gabinetes de archivos, páginas de anuncios, etc.) enviando 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 compatibilidad, consulta el parámetro kind en la Guía de referencia.

Creación de páginas o elementos nuevos

En este ejemplo, se crea una webpage nueva en el nivel superior del sitio, se incluyen algunos elementos XHTML para el cuerpo de la página y se establece el título del encabezado como "New WebPage Title":

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

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

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

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

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

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 tendría un encabezado de página de "Título de página web nuevo". Es decir, la <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 página filecabinet nueva con el encabezado "File Storage", 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) mediante la especificación del 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 nombrar la ruta de URL de una página:

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

Cómo crear subpáginas

Para crear subpáginas (secundarias) en una página principal, debes configurar el vínculo superior 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 en la primera página de anuncios que se encuentra en el feed de contenido del usuario. El título del anuncio se estableció como "Fiesta!!" y el contenido como "Mi lugar, este fin de semana".

Plantillas de páginas

Cómo crear plantillas de página

El proceso para crear una plantilla de página es el mismo que crear elementos o páginas nuevos y crear subpáginas.La diferencia es agregar el 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 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);

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

Al igual que cuando creas plantillas de página, 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 apunte al vínculo propio de una plantilla de página.

En este ejemplo, se crea una plantilla filecabinet nueva y, luego, se crea una instancia de una página 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>, aún es obligatorio incluir uno 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 permite subir archivos adjuntos a la página de gabinete de archivos o a una página superior.

Para subir un archivo adjunto a un elemento superior, envía una solicitud HTTP POST a la URL del canal 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, debes configurar 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 adjunto se crea con el título “Primeros pasos” y una descripción (opcional), “Paquete de HR”.

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 del archivo adjunto creado.

Sube un archivo adjunto a una carpeta

Para subir un archivo adjunto a una carpeta existente en un archivo 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"));

Archivos adjuntos web

Los archivos adjuntos web son tipos de archivos adjuntos especiales. En esencia, son vínculos a otros archivos de la Web que puedes agregar a las fichas de tu gabinete de archivos. Esta función es similar 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 gabinete de archivos. No se pueden subir a otros tipos de páginas.

En este ejemplo, se crea un elemento WebAttachmentEntry en los primeros FileCabinetPageEntry que se encuentran en el feed de contenido del usuario. El título y la descripción (opcional) están configurados en 'GoogleLogo' y 'colores lindo', 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!");

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 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 objeto ListPageEntry con los siguientes cambios:

El título se cambió a "Título actualizado"
El contenido HTML de la página se actualizó 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 de los archivos adjuntos

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. La AttachmentEntry que se muestra incluirá el contenido actualizado.

Cómo actualizar el contenido y los metadatos 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 a delete() de la entrada.

entry.delete();

También puedes usar el método delete() de la clase de servicio si le pasas el vínculo edit de la entrada y el valor de la ETag:

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

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

Volver al principio

Descargando 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 LCA

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

Cada entrada de LCA en el feed de LCA representa una función 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). Las entradas solo se mostrarán para 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 para compartir 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.

Roles

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

reader: Un lector (equivalente al acceso de solo lectura).
escritor: Es un colaborador (equivalente a acceso de lectura/escritura).
owner: Por lo general, es el administrador del sitio (equivalente al acceso de lectura y escritura).

Permisos

El elemento de alcance representa a 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: Una dirección de correo electrónico del Grupo de Google, p. ej., "grupo@dominio.com".
domain: Un nombre de dominio de G Suite, p. ej., "domain.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 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 para 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 el SiteFeed, cada SiteEntry contiene un vínculo a su feed de LCA. Por ejemplo, este fragmento recupera el feed de la LCA de un 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 esos 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 con la API, tu cliente debe crear un AclEntry nuevo y POSTlo en el servidor.

A continuación, se muestra un ejemplo en el que se agrega '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 valores de AclScope y AclRoles.

Uso compartido a nivel de grupo y dominio

Al igual que con compartir un sitio con un solo usuario, puedes compartir un sitio a través de un Grupo de Google o un dominio de G Suite.

Compartir contenido con la dirección de correo electrónico de un grupo:

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

Se comparte con todo un dominio:

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

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

Cómo modificar 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 según lo 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. Para ello, se actualiza "usuario@example.com" a fin de 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 ETags, consulta la guía de referencia de las APIs de datos de Google.

Eliminar permisos de uso compartido

Para quitar un permiso de uso compartido, primero recupera 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 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 antes, 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 realizar este tipo de recuperación condicional, los métodos getFeed() y getEntry() proporcionan un argumento adicional que acepta un valor 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 que especificaste. Si las ETags coinciden, el elemento no cambió y el servidor mostrará una excepción HTTP 304 NotModifiedException.

Si los ETags no coinciden, 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 datos de Google.

Volver al principio

Guía del lenguaje Java

Público

Cómo comenzar

Cómo instalar la biblioteca

Ejecuta la aplicación de muestra

Cómo comenzar tu propio proyecto

Autentica en la API de la versión clásica de Sites

AuthSub para aplicaciones web

Solicita un token de un solo uso

Actualiza a un token de sesión

Recupera información sobre un token de sesión

Revocar un token de sesión

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

Recupera un token de solicitud

Autoriza un token de solicitud

Actualiza a un token de acceso

ClientLogin en aplicaciones instaladas o para dispositivos móviles

Feed del sitio

Enumera sitios

Creación de sitios nuevos

Copia un sitio

Actualizar los metadatos de un sitio

Asignaciones de direcciones web

Cómo recuperar las asignaciones de direcciones web de un sitio

Modifica las asignaciones de direcciones web

Feed de actividad

Feed de revisiones

Canal de contenido

Cómo recuperar el canal de contenido

Ejemplos de consultas de feeds de contenido

Cómo recuperar tipos de entradas específicos

Cómo recuperar una página por ruta

Recuperar todas las entradas de una página principal

Creación de contenido

Creación de páginas o elementos nuevos

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

Cómo crear subpáginas

Plantillas de páginas

Cómo crear plantillas de página

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

Cómo subir archivos

Subiendo archivos adjuntos

Sube un archivo adjunto a una carpeta

Archivos adjuntos web

Actualización de contenido

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

Actualizando el contenido de los archivos adjuntos

Cómo actualizar el contenido y los metadatos de los archivos adjuntos

Eliminación de contenido

Descargando archivos adjuntos

Feed de LCA

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

Roles

Permisos

Recupera el feed de LCA

Compartir un sitio

Uso compartido a nivel de grupo y dominio

Cómo modificar los permisos de uso compartido

Eliminar permisos de uso compartido

Temas especiales

Cómo volver a recuperar un feed o una entrada