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
Actualiza a un token de sesión
Consulta Cómo usar AuthSub con las bibliotecas cliente de la API de datos de Google.
Recupera información sobre un token de sesión
Consulta Cómo usar AuthSub con las bibliotecas cliente de la API de datos de Google.
Revocar un token de sesión
Consulta Cómo usar AuthSub con las bibliotecas cliente de la API de datos de Google.
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.
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.
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.
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.
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.
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 cona-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 cona-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".
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");
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
.
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.");
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 POST
lo 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.
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.