Obsoleto: La API de Sites está obsoleta y es posible que deje de funcionar en cualquier momento. La API de Sites solo puede acceder a la versión clásica de Sites. La API de Sites no puede acceder a la versión recompilada de Sites que se lanzó el 22 de noviembre de 2016.

Guía del lenguaje Java

Importante: Este documento se escribió 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 el 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 Google Sites Data permite que las aplicaciones cliente accedan, publiquen y modifiquen contenido en un sitio de Google. Tu aplicación cliente también puede solicitar una lista de la actividad reciente, recuperar el historial de revisiones y descargar archivos adjuntos.

Además de proporcionar información general sobre las capacidades de la API de Sites Data, esta guía incluye ejemplos para 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 Cómo comenzar a usar la biblioteca cliente de Google Data para Java. Si te interesa obtener más información sobre el protocolo subyacente que usa la biblioteca cliente de Java para interactuar con la API de Sites clásica, consulta la guía de protocolos.

Público

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

Cómo comenzar

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

Cómo instalar la biblioteca

Para obtener ayuda con la configuración y la instalación de la biblioteca cliente, consulta la Guía de inicio rápido de la biblioteca cliente de Google Data para Java. Si usas Eclipse, en ese artículo también se 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:

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

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

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

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

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

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

Cómo iniciar tu propio proyecto

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

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

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

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

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

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

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

Autenticación en la API de Sites clásica

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

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

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

AuthSub para aplicaciones web

Las aplicaciones cliente que necesiten autenticar a sus usuarios en Cuentas de Google deben usar la autenticación de AuthSub para aplicaciones web. El operador no necesita acceder 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 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 Google Data para Java 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 deseas autenticar usuarios en tu dominio alojado de G Suite, haz lo siguiente:

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() toma varios parámetros (que corresponden a los parámetros de consulta que usa el controlador AuthSubRequest):

La URL de próximo paso: Es la URL a la que Google redireccionará al usuario después de que acceda a su cuenta y 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 el 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 más adelante o no; true en el ejemplo anterior

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

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

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

Cómo recuperar un token de solicitud

Consulta Cómo usar OAuth con las bibliotecas cliente de las APIs de Google Data.

Autoriza un token de solicitud

Consulta Cómo usar OAuth con las bibliotecas cliente de las APIs de Google Data.

Actualiza a un token de acceso

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

ClientLogin para aplicaciones instaladas o para dispositivos móviles

Las aplicaciones instaladas o para dispositivos móviles que necesiten autenticar a sus usuarios en las Cuentas de Google deben usar ClientLogin. En la primera ejecución, tu aplicación le solicita al usuario su nombre de usuario y contraseña. En las 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: Una vez que tu aplicación haya autenticado correctamente al usuario por primera vez, almacena el token de autenticación en tu base de datos para usarlo más adelante. No es necesario solicitar la contraseña del usuario cada vez que se ejecuta la aplicación. Consulta Cómo revocar un token de autorización para obtener más información.

Para obtener más información sobre el uso de ClientLogin en tus aplicaciones de Java, consulta Cómo usar ClientLogin con las bibliotecas cliente de las APIs de Google Data.

Volver al principio

Feed del sitio

El feed de sitios se puede usar para enumerar los sitios de Google Sites que posee un usuario 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.

Sitios de la ficha

Para consultar el feed de sitios, envía una solicitud HTTP GET a la URL del feed de sitios:

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 de código 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.

Cómo crear sitios nuevos

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

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

En este ejemplo, se crea un sitio nuevo con el tema "slate" (parámetro de configuración opcional) y se proporcionan el nombre (obligatorio) y la descripción (opcional) del sitio:

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

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

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

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

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

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

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

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

Cómo copiar un sitio

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

Copiar un sitio es similar a crear uno nuevo. La diferencia es que debes establecer un vínculo en tu nuevo SiteEntry que incluya el vínculo propio del sitio que se duplicará. A continuación, se muestra un ejemplo de cómo duplicar el sitio creado en la sección Creación de sitios nuevos:

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

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

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

Puntos importantes:

Solo se pueden copiar los sitios y las plantillas de sitios que pertenecen al usuario autenticado.
También se puede copiar una plantilla de sitio. Un sitio es una plantilla si 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, siempre y cuando aparezcas como propietario en el sitio de origen.

Cómo actualizar los metadatos de un sitio

Para cambiar el nombre de un sitio, su tema, su etiqueta de categoría o su resumen, primero deberás recuperar 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 cambia su nombre:

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

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

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

SiteEntry updatedSiteEntry = myTwin.update();

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

Asignaciones de direcciones web

Las asignaciones de direcciones web permiten que los usuarios de Sites asignen sus propios dominios a un sitio de Google. Por ejemplo, http://www.mydomainsite.com se puede usar 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. Consulta nuestro artículo del Centro de ayuda para obtener más información.

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

Para devolver 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 links con rel='webAddressMapping'. Por ejemplo, en el ejemplo anterior, hay tres 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 se trabaja con asignaciones de direcciones web. Si el parámetro no está presente, no se devolverá webAddressMappings en las entradas del sitio (GET) ni se tendrá en cuenta cuando se actualicen o quiten (PUT) las asignaciones de una entrada.

Para agregar, actualizar o borrar una asignación, simplemente especifica, cambia o quita ese vínculo cuando crees sitios nuevos o actualices los metadatos de un sitio. El parámetro with-mappings=true debe incluirse en el URI del feed de sitios. Nota: Para actualizar las asignaciones de direcciones, debes ser administrador del sitio o administrador del 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 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 en el momento de crear o copiar un sitio.

Volver al principio

Feed de actividad

Puedes recuperar la actividad reciente (cambios) de un sitio recuperando 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 una solicitud 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 devolver objetos ActivityEntry:

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

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

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

Volver al principio

Feed de revisión

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

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

En este ejemplo, se consulta el feed de contenido y, luego, se recupera el feed de revisión 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 de AuthSub, OAuth o ClientLogin. Consulta Cómo autenticarse en el servicio de Sites.

Volver al principio

Feed de contenido

Cómo recuperar el feed de contenido

El feed de contenido enumera el contenido más reciente de un sitio. Se puede acceder a él enviando un GET HTTP a la URL del feed 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`	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. El ContentFeed contendrá diferentes tipos de objetos, todos heredados de BaseContentEntry: ListItemEntry, ListPageEntry, AttachmentEntry, WebAttachmentEntry, FileCabinetPageEntry, AnnouncementsPageEntry, AnnouncementEntry, WebPageEntry, CommentEntry.

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

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

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

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

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

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

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

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

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

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

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

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

Nota: Es posible que este feed requiera o no autenticación, según los permisos de uso compartido del sitio. Si el sitio no es público, tu cliente debe autenticarse con un token de AuthSub, OAuth o ClientLogin. Consulta Cómo autenticarse 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 Google Data y los específicos de la API de Sites clásica. Para obtener información más detallada y una lista completa de los parámetros admitidos, consulta la Guía de referencia.

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

Cómo recuperar tipos de entrada específicos

Para recuperar solo un tipo de entrada en particular, usa el parámetro kind. Este ejemplo muestra solo las entradas de attachment:

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

Para devolver más de un tipo de entrada, separa cada kind con una coma (“,”). En este ejemplo, se devuelven entradas de 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 su 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 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());
}

Cómo 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 hay):

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

Para obtener más parámetros, consulta la Guía de referencia.

Volver al principio

Creación de contenido

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

Para crear contenido nuevo (páginas web, páginas de listas, páginas de archivador, páginas de anuncios, etc.), envía una solicitud HTTP POST al feed de contenido:

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

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

Cómo crear elementos o páginas nuevos

En este ejemplo, se crea un nuevo webpage en el nivel superior del sitio, se incluye algo de XHTML para el cuerpo de la página y se establece el título del encabezado en "Título de la página web nueva":

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.

Cómo crear elementos o páginas en rutas de URL personalizadas

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

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

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

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

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

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

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

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

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

Cómo crear subpáginas

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

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 announcement en la primera página de anuncios que se encuentra en el feed de contenido del usuario. El título del anuncio se establece en "¡Fiesta!" y el contenido en "En mi casa, este fin de semana".

Plantillas de páginas

Crea plantillas de páginas

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

En este ejemplo, se crea una plantilla de 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áginas, puedes crear una instancia de una página nueva a partir de una plantilla si incluyes un <link> con rel='http://schemas.google.com/sites/2008#template' que 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 página filecabinet nueva a partir de esa plantilla.

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

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

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

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

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

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

Nota: A pesar de que una plantilla define un <category>, sigue siendo necesario incluir uno en tu entrada. Ten en cuenta también 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 a la página de archivador o a una página principal.

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

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

Todos los tipos de archivos adjuntos se deben subir a una página principal. Por lo tanto, debes establecer un vínculo principal 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 objeto 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 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 del archivo adjunto creado.

Cómo subir un archivo adjunto a una carpeta

Para subir un archivo adjunto a una carpeta existente en un objeto 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 adjuntos web son tipos especiales de adjuntos. Básicamente, son vínculos a otros archivos en la Web que puedes agregar a tus fichas de archivador. Esta función es análoga al método de carga "Agregar archivo por URL" en la IU de Google Sites.

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

En este ejemplo, se crea un WebAttachmentEntry debajo del primer FileCabinetPageEntry que se encuentra en el feed de contenido del usuario. Su título y su descripción (opcional) se establecen en "GoogleLogo" y "nice colors", respectivamente.

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

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

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

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

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

POST crea un vínculo en el archivador 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. Esto enviará una solicitud HTTP PUT 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 modificó a "Título actualizado".
El contenido HTML de la página se actualiza a "<p>Updated HTML Content</p>".
El encabezado de la primera columna de la lista cambia a "Propietario".

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

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

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

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

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

ListPageEntry updatedEntry = listPage.update();

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

Actualiza el contenido del archivo adjunto

En el caso de AttachmentEntry, también puedes actualizar el contenido configurando el MediaSource de la entrada y, luego, usando el método updateMedia(boolean) de la entrada.

En este ejemplo, se actualizará el contenido de un 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 HTTP PUT al vínculo edit-media de la entrada. El objeto AttachmentEntry que se devuelve contendrá el contenido actualizado.

Actualización de metadatos y contenido de adjuntos

Puedes actualizar los metadatos y el contenido de un adjunto 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 adjunto a "Título nuevo", se actualiza su descripción y se reemplaza el contenido del archivo por un nuevo archivo .zip. Dado que la solicitud contiene contenido de archivo nuevo, se usa el updateMedia() de AttachmentEntry.

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

  return entry.updateMedia(true);
}

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

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

Volver al principio

Cómo borrar contenido

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

entry.delete();

También puedes usar el método delete() de la clase de servicio pasando 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

Descarga de archivos adjuntos

Para descargar un AttachmentEntry, envía una solicitud GET HTTP 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 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). 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" de la pantalla de uso compartido de la IU de Google Sites. Por lo tanto, no se mostrarán los administradores del dominio, aunque tengan acceso implícito a un sitio.

Funciones

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

lector: Es un visualizador (equivalente al acceso de solo lectura).
writer: Es un colaborador (equivalente al acceso de lectura y escritura).
owner: Por lo general, es el administrador del sitio (equivalente al acceso de lectura y escritura).

Permisos

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

user: Es un valor de dirección de correo electrónico, p. ej., "usuario@gmail.com".
group: Es una dirección de correo electrónico de un grupo de Google, p. ej., "group@domain.com".
domain: Es un nombre de dominio de G Suite, p. ej., "domain.com".
default: Solo hay un alcance posible de tipo "default", que no tiene 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 establecido en acceso de "propietario"; solo pueden ser lectores o escritores.

Cómo recuperar el feed de la 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 la LCA de un sitio determinado y se imprimen los permisos de cada AclEntry:

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

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

getAclFeed('my-site-name');

Si trabajas con entradas en SiteFeed, cada SiteEntry contiene un vínculo a su feed de LCA. Por ejemplo, este fragmento recupera el feed de LCA de un 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: Es posible que ciertas LCA de uso compartido solo sean posibles si el dominio está configurado para permitir esos permisos (p. ej., si está habilitado el uso compartido fuera del dominio para los dominios de G Suite, etc.).

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

Este es un ejemplo que agrega "usuario@ejemplo.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 valores posibles de AclScope y AclRoles.

Uso compartido a nivel del grupo y del dominio

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

Compartir contenido con una dirección de correo electrónico grupal:

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

Compartir con todo un dominio:

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 solo para el dominio en el que se aloja el sitio. Por ejemplo, http://sites.google.com/a/dominio1.com/sitioA solo puede compartir todo el sitio con dominio1.com, no con dominio2.com. Los sitios que no están alojados en un dominio de G Suite (p.ej., http://sites.google.com/site/sitioB) no pueden invitar dominios.

Cómo modificar los permisos de uso compartido

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

En este ejemplo, se modifica el ejemplo anterior de aclEntry de la sección Cómo compartir un sitio actualizando "user@example.com" para que sea un writer (colaborador):

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

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

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

Cómo quitar 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 etiquetas ETag, consulta la guía de referencia de las APIs de datos de Google.

Volver al principio

Temas especiales

Cómo recuperar un feed o una entrada

Si quieres recuperar un feed o una entrada que ya recuperaste, puedes mejorar la eficiencia indicándole al servidor que envíe la lista o la entrada solo si cambiaron desde la última vez que las recuperaste.

Para realizar 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 al ETag de una entrada desde entry.getEtag().

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

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

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

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

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

Volver al principio

Guía del lenguaje Java Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

Público

Cómo comenzar

Cómo instalar la biblioteca

Ejecuta la aplicación de muestra

Cómo iniciar tu propio proyecto

Autenticación en la API de Sites clásica

AuthSub para aplicaciones web

Solicita un token de un solo uso

Actualiza a un token de sesión

Cómo recuperar información sobre un token de sesión

Cómo revocar un token de sesión

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

Cómo recuperar un token de solicitud

Autoriza un token de solicitud

Actualiza a un token de acceso

ClientLogin para aplicaciones instaladas o para dispositivos móviles

Feed del sitio

Sitios de la ficha

Cómo crear sitios nuevos

Cómo copiar un sitio

Cómo actualizar los metadatos de un sitio

Asignaciones de direcciones web

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

Cómo modificar las asignaciones de direcciones web

Feed de actividad

Feed de revisión

Feed de contenido

Cómo recuperar el feed de contenido

Ejemplos de consultas de feeds de contenido

Cómo recuperar tipos de entrada específicos

Cómo recuperar una página por su ruta

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

Creación de contenido

Cómo crear elementos o páginas nuevos

Cómo crear elementos o páginas en rutas de URL personalizadas

Cómo crear subpáginas

Plantillas de páginas

Crea plantillas de páginas

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

Cómo subir archivos

Subiendo archivos adjuntos

Cómo subir un archivo adjunto a una carpeta

Archivos adjuntos web

Actualización de contenido

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

Actualiza el contenido del archivo adjunto

Actualización de metadatos y contenido de adjuntos

Cómo borrar contenido

Descarga de archivos adjuntos

Feed de LCA

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

Funciones

Permisos

Cómo recuperar el feed de la LCA

Cómo compartir un sitio

Uso compartido a nivel del grupo y del dominio

Cómo modificar los permisos de uso compartido

Cómo quitar permisos de uso compartido

Temas especiales

Cómo recuperar un feed o una entrada

Guía del lenguaje Java