Important:Ce document a été rédigé avant 2012. Les options d'authentification décrites dans ce document (OAuth 1.0, AuthSub et ClientLogin) ont été officiellement abandonnées depuis le 20 avril 2012 et ne sont plus disponibles. Nous vous encourageons à migrer vers OAuth 2.0 dès que possible.
L'API Google Sites Data permet aux applications clientes d'accéder au contenu d'un site Google, de le publier et de le modifier. Votre application cliente peut également demander la liste des activités récentes, récupérer l'historique des révisions et télécharger des pièces jointes.
En plus de fournir des informations générales sur les fonctionnalités de l'API Sites Data, ce guide fournit des exemples d'interaction avec l'API à l'aide de la bibliothèque cliente Python. Pour obtenir de l'aide sur la configuration de la bibliothèque cliente, consultez la page Premiers pas avec la bibliothèque cliente Python Google Data. Pour en savoir plus sur le protocole sous-jacent utilisé par la bibliothèque cliente Python pour interagir avec l'API de la version classique de Sites, consultez le guide du protocole.
Audience
Ce document est destiné aux développeurs qui souhaitent écrire des applications clientes interagissant avec Google Sites à l'aide de la bibliothèque cliente Python Google Data.
Premiers pas
Pour utiliser la bibliothèque cliente Python, vous devez disposer de Python 2.2 ou d'une version ultérieure, ainsi que des modules listés sur la page wiki DependencyModules. Après avoir téléchargé la bibliothèque cliente, consultez Premiers pas avec la bibliothèque Python Google Data pour obtenir de l'aide concernant l'installation et l'utilisation du client.
Exécuter l'exemple
Vous trouverez un exemple complet dans le sous-répertoire samples/sites du dépôt Mercurial du projet (/samples/sites/sites_example.py).
Exécutez l'exemple comme suit:
python sites_example.py # or python sites_example.py --site [sitename] --domain [domain or "site"] --debug [prints debug info if set]
Si les indicateurs requis ne sont pas fournis, l'application vous invite à saisir ces valeurs. L'exemple permet à l'utilisateur d'effectuer un certain nombre d'opérations qui montrent comment utiliser l'API de la version classique de Sites. Par conséquent, vous devez vous authentifier pour effectuer certaines opérations (par exemple, modifier le contenu). Le programme vous invite également à vous authentifier via AuthSub, OAuth ou ClientLogin.
Pour inclure les exemples de ce guide dans votre propre code, vous avez besoin des instructions import suivantes:
import atom.data import gdata.sites.client import gdata.sites.data
Vous devez également configurer un objet SitesClient, qui représente une connexion client à l'API de la version classique de Sites.
Transmettez le nom de votre application et le nom de l'espace Web du site (à partir de son URL):
client = gdata.sites.client.SitesClient(source='yourCo-yourAppName-v1', site='yourSiteName')
Pour travailler sur un site hébergé sur un domaine G Suite, définissez le domaine à l'aide du paramètre domain:
client = gdata.sites.client.SitesClient(source='yourCo-yourAppName-v1', site='yourSiteName', domain='example.com')
Dans les extraits ci-dessus, l'argument source est facultatif, mais recommandé pour la journalisation. Il doit respecter le format suivant: company-applicationname-version
Remarque: La suite du guide suppose que vous avez créé un objet SitesClient dans la variable client.
Authentification dans l'API Google Sites classique
La bibliothèque cliente Python peut être utilisée pour travailler avec des flux publics ou privés. L'API Sites Data permet d'accéder aux flux privés et publics, en fonction des autorisations accordées à un site et de l'opération que vous essayez d'effectuer. Par exemple, vous pouvez lire le flux de contenu d'un site public, mais ne pas le mettre à jour (ce qui nécessite un client authentifié). Pour ce faire, utilisez l'authentification par nom d'utilisateur/mot de passe ClientLogin, AuthSub ou OAuth.
Pour plus d'informations sur AuthSub, OAuth et ClientLogin, consultez la page Présentation de l'authentification via les API Google Data.
AuthSub pour les applications Web
L'authentification AuthSub pour les applications Web doit être utilisée par les applications clientes qui doivent authentifier leurs utilisateurs auprès de comptes Google ou G Suite. L'opérateur n'a pas besoin d'accéder au nom d'utilisateur ni au mot de passe de l'utilisateur Google Sites. Seul un jeton AuthSub est requis.
Afficher les instructions pour intégrer AuthSub à votre application Web
Demander un jeton à usage unique
Lorsque l'utilisateur accède à votre application pour la première fois, il doit s'authentifier. En règle générale, les développeurs impriment du texte et un lien redirigeant l'utilisateur vers la page d'approbation AuthSub pour l'authentifier et demander l'accès à ses documents. La bibliothèque cliente Python Google Data fournit une fonction generate_auth_sub_url() permettant de générer cette URL. Le code ci-dessous établit un lien vers la page AuthSubRequest.
import gdata.gauth def GetAuthSubUrl(): next = 'http://www.example.com/myapp.py' scopes = ['https://sites.google.com/feeds/'] secure = True session = True return gdata.gauth.generate_auth_sub_url(next, scopes, secure=secure, session=session) print '<a href="%s">Login to your Google account</a>' % GetAuthSubUrl()
Si vous souhaitez authentifier les utilisateurs sur un domaine hébergé par G Suite, transmettez le nom de domaine à generate_auth_sub_url():
def GetAuthSubUrl(): domain = 'example.com' next = 'http://www.example.com/myapp.py' scopes = ['https://sites.google.com/feeds/'] secure = True session = True return gdata.gauth.generate_auth_sub_url(next, scopes, secure=secure, session=session, domain=domain)
La méthode generate_auth_sub_url() utilise plusieurs paramètres (correspondant aux paramètres de requête utilisés par le gestionnaire AuthSubRequest):
- L'URL next (suivante) : URL vers laquelle Google redirigera l'utilisateur une fois que l'utilisateur s'est connecté à son compte et a accordé l'accès ;
http://www.example.com/myapp.pydans l'exemple ci-dessus - le champ d'application :
https://sites.google.com/feeds/ - secure, une valeur booléenne indiquant si le jeton sera utilisé ou non en mode sécurisé et enregistré ;
Truedans l'exemple ci-dessus - session, une seconde valeur booléenne indiquant si le jeton à usage unique sera ultérieurement échangé contre un jeton de session (
Truedans l'exemple ci-dessus)
Passer à un jeton de session
Consultez la page Utiliser AuthSub avec les bibliothèques clientes des API Google Data.
Récupérer des informations sur un jeton de session
Consultez la page Utiliser AuthSub avec les bibliothèques clientes des API Google Data.
Révoquer un jeton de session
Consultez la page Utiliser AuthSub avec les bibliothèques clientes des API Google Data.
Conseil: Une fois que votre application a acquis un jeton de session de longue durée, stockez-le dans votre base de données pour le rappeler pour une utilisation ultérieure. Il n'est pas nécessaire de renvoyer l'utilisateur vers AuthSub à chaque exécution de l'application.
Utilisez client.auth_token = gdata.gauth.AuthSubToken(TOKEN_STR) pour définir un jeton existant sur le client.
OAuth pour le Web ou pour les applications installées/mobiles
OAuth peut être utilisé à la place d'AuthSub et est destiné aux applications Web. OAuth s'apparente au mode sécurisé et enregistré d'AuthSub dans la mesure où toutes les requêtes de données doivent être signées numériquement et vous devez enregistrer votre domaine.
Afficher les instructions pour intégrer OAuth dans votre application installée
Extraire un jeton de requête
Consultez la page Utiliser OAuth avec les bibliothèques clientes des API Google Data.
Autoriser un jeton de requête
Consultez la page Utiliser OAuth avec les bibliothèques clientes des API Google Data.
Passer à un jeton d'accès
Consultez la page Utiliser OAuth avec les bibliothèques clientes des API Google Data.
Conseil: Une fois que votre application a obtenu un jeton d'accès OAuth, stockez-le dans votre base de données pour le rappeler pour une utilisation ultérieure. Il n'est pas nécessaire de renvoyer l'utilisateur via OAuth à chaque exécution de votre application.
Utilisez client.auth_token = gdata.oauth.OAuthToken(TOKEN_STR, TOKEN_SECRET) pour définir un jeton existant sur le client.
ClientLogin pour les applications installées/mobiles
ClientLogin doit être utilisé par les applications installées ou mobiles qui doivent authentifier leurs utilisateurs auprès des comptes Google. À la première exécution, votre application invite l'utilisateur à saisir son nom d'utilisateur/mot de passe. Dans les requêtes suivantes, un jeton d'authentification est référencé.
Afficher les instructions pour intégrer ClientLogin à votre application installée
Pour utiliser ClientLogin, appelez la méthode ClientLogin() de l'objet SitesClient, hérité de GDClient. Spécifiez l'adresse e-mail et le mot de passe de l'utilisateur au nom duquel votre client effectue des requêtes. Exemple :
client = gdata.sites.client.SitesClient(source='yourCo-yourAppName-v1') client.ClientLogin('user@gmail.com', 'pa$$word', client.source);
Conseil: Une fois que l'application a authentifié l'utilisateur pour la première fois, stockez le jeton d'authentification dans votre base de données pour le rappeler pour une utilisation ultérieure. Il n'est pas nécessaire de demander à l'utilisateur son mot de passe à chaque exécution de l'application. Pour en savoir plus, consultez la section Rappeler un jeton d'authentification.
Pour en savoir plus sur l'utilisation de ClientLogin dans vos applications Python, consultez la page Utiliser ClientLogin avec les bibliothèques clientes des API Google Data.
Flux d'actualisation
Ce flux permet de répertorier les sites Google appartenant à un utilisateur ou pour lesquels il dispose d'autorisations de consultation. Elle peut également être utilisée pour modifier le nom d'un site existant. Enfin, pour les domaines G Suite, il permet également de créer et/ou de copier l'intégralité d'un site.
Répertorier les sites
Pour répertorier les sites auxquels un utilisateur a accès, utilisez la méthode GetSiteFeed() du client. La méthode utilise un argument facultatif, uri, que vous pouvez utiliser pour spécifier un autre URI de flux de site. Par défaut, GetSiteFeed() utilise le nom de site et le domaine définis sur l'objet client. Consultez la section Premiers pas pour en savoir plus sur la définition de ces valeurs sur votre objet client.
Voici un exemple de récupération de la liste de sites de l'utilisateur authentifié:
feed = client.GetSiteFeed()
for entry in feed.entry:
print '%s (%s)' % (entry.title.text, entry.site_name.text)
if entry.summary.text:
print 'description: ' + entry.summary.text
if entry.FindSourceLink():
print 'this site was copied from site: ' + entry.FindSourceLink()
print 'acl feed: %s\n' % entry.FindAclLink()
print 'theme: ' + entry.theme.text
L'extrait ci-dessus imprime le titre du site, son nom, le site à partir duquel il a été copié, ainsi que l'URI de son flux LCA.
Créer des sites
Remarque: Cette fonctionnalité n'est disponible que pour les domaines G Suite.
Les nouveaux sites peuvent être provisionnés en appelant la méthode CreateSite() de la bibliothèque.
Comme pour l'outil d'aide GetSiteFeed(), CreateSite() accepte également un argument facultatif, uri, que vous pouvez utiliser pour spécifier un autre URI de flux de site (si vous créez le site dans un domaine différent de celui défini sur votre objet SitesClient).
Voici un exemple de création d'un site avec le thème "Slate" et en fournissant un titre et une description (facultative) :
client.domain = 'example2.com' # demonstrates creating a site under a different domain.
entry = client.CreateSite('Title For My Site', description='Site to hold precious memories', theme='slate')
print 'Site created! View it at: ' + entry.GetAlternateLink().href
La requête ci-dessus crée un site sous le domaine G Suite example2.com.
L'URL du site est donc https://sites.google.com/a/example2.com/titre-pour-mon-site.
Si le site a bien été créé, le serveur renvoie un objet gdata.sites.data.SiteEntry contenant des éléments ajoutés par le serveur: un lien vers le site, un lien vers le flux LCA du site, le nom du site, le titre, le résumé, etc.
Copie d'un site
Remarque: Cette fonctionnalité n'est disponible que pour les domaines G Suite.
CreateSite() peut également être utilisé pour copier un site existant. Pour ce faire, transmettez l'argument de mot clé source_site.
Tous les sites copiés disposeront de ce lien, qui est accessible via entry.FindSourceLink(). Voici un exemple de duplication du site créé dans la section Créer des sites:
copied_site = client.CreateSite('Copy of Title For My Site', description='My Copy', source_site=entry.FindSourceLink())
print 'Site copied! View it at: ' + copied_site.GetAlternateLink().href
Points importants:
- Seuls les sites et modèles de site appartenant à l'utilisateur authentifié peuvent être copiés.
- Un modèle de site peut également être copié. Un site est considéré comme un modèle si le paramètre "Publier ce site comme modèle" est coché sur la page des paramètres de Google Sites.
- Vous pouvez copier un site à partir d'un autre domaine, tant que vous n'êtes pas listé en tant que propriétaire sur le site source.
Mettre à jour les métadonnées d'un site
Pour modifier le titre ou le résumé d'un site, vous avez besoin d'un SiteEntry contenant le site en question. Cet exemple utilise la méthode GetEntry() pour d'abord récupérer un élément SiteEntry, puis modifier son titre, sa description et sa balise de catégorie:
uri = 'https://sites.google.com/feeds/site/example2.com/title-for-my-site'
site_entry = client.GetEntry(uri, desired_class=gdata.sites.data.SiteEntry)
site_entry.title.text = 'Better Title'
site_entry.summary.text = 'Better Description'
category_name = 'My Category'
category = atom.data.Category(
scheme=gdata.sites.data.TAG_KIND_TERM,
term=category_name)
site_entry.category.append(category)
updated_site_entry = client.Update(site_entry)
# To force the update, even if you do not have the latest changes to the entry:
# updated_site_entry = client.Update(site_entry, force=True)
Récupération du flux d'activités
Remarque: Pour accéder à ce flux, vous devez être un collaborateur ou un propriétaire du site. Votre client doit s'authentifier à l'aide d'un jeton AuthSub, OAuth ou ClientLogin. Consultez la section Authentification auprès du service Sites.
Vous pouvez récupérer l'activité récente d'un site (modifications) en récupérant le flux d'activité.
La méthode GetActivityFeed() de la bibliothèque permet d'accéder à ce flux:
print "Fetching activity feed of '%s'...\n" % client.site feed = client.GetActivityFeed() for entry in feed.entry: print '%s [%s on %s]' % (entry.title.text, entry.Kind(), entry.updated.text)
L'appel de GetActivityFeed() renvoie un objet gdata.sites.data.ActivityFeed contenant une liste de gdata.sites.data.ActivityEntry. Chaque entrée d'activité contient des informations
sur une modification apportée au site.
Récupération de l'historique des révisions
Remarque: Pour accéder à ce flux, vous devez être un collaborateur ou un propriétaire du site. Votre client doit s'authentifier à l'aide d'un jeton AuthSub, OAuth ou ClientLogin. Consultez la section Authentification auprès du service Sites.
Le flux de révision fournit des informations sur l'historique des révisions de toutes les entrées de contenu. La méthode GetRevisionFeed() peut être utilisée pour récupérer les révisions d'une entrée de contenu donnée. La méthode utilise un paramètre uri facultatif qui accepte un gdata.sites.data.ContentEntry, un URI complet d'une entrée de contenu ou un ID d'entrée de contenu.
L'exemple suivant interroge le flux de contenu et extrait le flux de révision pour la première entrée de contenu:
print "Fetching content feed of '%s'...\n" % client.site content_feed = client.GetContentFeed() content_entry = content_feed.entry[0] print "Fetching revision feed of '%s'...\n" % content_entry.title.text revision_feed = client.GetRevisionFeed(content_entry) for entry in revision_feed.entry: print entry.title.text print ' new version on:\t%s' % entry.updated.text print ' view changes:\t%s' % entry.GetAlternateLink().href print ' current version:\t%s...\n' % str(entry.content.html)[0:100]
L'appel de GetRevisionFeed() renvoie un objet gdata.sites.data.RevisionFeed contenant une liste de gdata.sites.data.RevisionEntry. Chaque entrée de révision contient des informations telles que le contenu de la révision, le numéro de version et la date de création de la version.
Flux de contenu
Récupérer le flux de contenu
Remarque: En fonction des autorisations de partage du Site, le flux de contenu peut nécessiter ou non une authentification. Si le Site n'est pas public, votre client doit s'authentifier à l'aide d'un jeton AuthSub, OAuth ou ClientLogin. Consultez la section S'authentifier sur le service Sites.
Le flux de contenu affiche le contenu le plus récent d'un site. Vous pouvez y accéder en appelant la méthode GetContentFeed() de la bibliothèque, qui accepte un paramètre de chaîne uri facultatif pour transmettre une requête personnalisée.
Voici un exemple de récupération de l'intégralité du flux de contenu et d'impression de quelques éléments intéressants:
print "Fetching content feed of '%s'...\n" % client.site
feed = client.GetContentFeed()
for entry in feed.entry:
print '%s [%s]' % (entry.title.text, entry.Kind())
# Common properties of all entry kinds.
print ' content entry id: ' + entry.GetNodeId()
print ' revision:\t%s' % entry.revision.text
print ' updated:\t%s' % entry.updated.text
if entry.page_name:
print ' page name:\t%s' % entry.page_name.text
if entry.content:
print ' content\t%s...' % str(entry.content.html)[0:100]
# Subpages/items will have a parent link.
parent_link = entry.FindParentLink()
if parent_link:
print ' parent link:\t%s' % parent_link
# The alternate link is the URL pointing to Google Sites.
if entry.GetAlternateLink():
print ' view in Sites:\t%s' % entry.GetAlternateLink().href
# If this entry is a filecabinet, announcementpage, etc., it will have a feed of children.
if entry.feed_link:
print ' feed of items:\t%s' % entry.feed_link.href
print
Conseil: entry.Kind() peut être utilisé pour déterminer le type d'une entrée.
L'objet feed obtenu est un gdata.sites.data.ContentFeed contenant une liste de gdata.sites.data.ContentEntry. Chaque entrée représente une page ou un élément différent du site de l'utilisateur et comporte des éléments spécifiques au type d'entrée dont il s'agit. Consultez l'exemple d'application pour une meilleure idée des propriétés disponibles pour chaque type d'entrée.
Exemples de requêtes pour le flux de contenu
Vous pouvez effectuer une recherche dans le flux de contenu à l'aide de certains paramètres de requête standards de l'API Google Data et de ceux spécifiques à l'API de la version classique de Sites. Pour obtenir des informations plus détaillées et la liste complète des paramètres acceptés, consultez le guide de référence.
Remarque: Les exemples de cette section utilisent la méthode d'assistance gdata.sites.client.MakeContentFeedUri() pour créer l'URI de base du flux de contenu.
Récupérer des types d'entrées spécifiques
Pour récupérer uniquement un type d'entrée particulier, utilisez le paramètre kind. Par exemple, cet extrait ne renvoie que des entrées attachment:
kind = 'webpage' print 'Fetching only %s entries' % kind uri = '%s?kind=%s' % (client.MakeContentFeedUri(), kind) feed = client.GetContentFeed(uri=uri)
Pour renvoyer plusieurs types, séparez chaque élément kind par une virgule. Par exemple, cet extrait renvoie les entrées filecabinet et listpage:
kind = ','.join(['filecabinet', 'listpage']) print 'Fetching only %s entries' % kind uri = '%s?kind=%s' % (client.MakeContentFeedUri(), kind) feed = client.GetContentFeed(uri=uri)
Récupérer une page par chemin d'accès
Si vous connaissez le chemin relatif d'une page dans le site Google, vous pouvez utiliser le paramètre path pour récupérer cette page particulière.
L'exemple suivant renvoie la page située à l'emplacement http://sites.google.com/domainName/siteName/path/to/the/page:
path = '/path/to/the/page' print 'Fetching page by its path: ' + path uri = '%s?path=%s' % (client.MakeContentFeedUri(), path) feed = client.GetContentFeed(uri=uri)
Récupérer toutes les entrées d'une page parente
Si vous connaissez l'ID d'entrée de contenu d'une page (par exemple, "1234567890" dans l'exemple ci-dessous), vous pouvez utiliser le paramètre parent pour récupérer toutes ses entrées enfants (le cas échéant):
parent = '1234567890' print 'Fetching all children of parent entry: ' + parent uri = '%s?parent=%s' % (client.MakeContentFeedUri(), parent) feed = client.GetContentFeed(uri=uri)
Pour en savoir plus sur les paramètres supplémentaires, consultez le Guide de référence.
Création de contenu
Remarque:Avant de créer du contenu pour un site, assurez-vous de l'avoir défini dans le client.client.site = "siteName"
Vous pouvez créer du contenu (pages Web, listes, classeurs, pages d'annonces, etc.) à l'aide de CreatePage().
Le premier argument de cette méthode doit être le type de page à créer, suivi du titre et de son contenu HTML.
Pour obtenir la liste des types de nœuds compatibles, consultez le paramètre kind dans le guide de référence.
Créer des éléments / pages
Cet exemple crée un webpage sous l'élément de premier niveau, inclut du code XHTML pour le corps de la page et définit le titre de l'en-tête sur "New WebPage Title":
entry = client.CreatePage('webpage', 'New WebPage Title', html='<b>HTML content</b>')
print 'Created. View it at: %s' % entry.GetAlternateLink().href
Si la requête aboutit, entry contient une copie de l'entrée créée sur le serveur, sous la forme d'un gdata.sites.gdata.ContentEntry.
Pour créer un genre d'entrée plus complexe renseigné lors de la création (par exemple, un listpage avec des en-têtes de colonne), vous devez créer le gdata.sites.data.ContentEntry manuellement, renseigner les propriétés qui vous intéressent et appeler client.Post().
Créer des éléments/pages sous des chemins d'URL personnalisés
Par défaut, l'exemple précédent serait créé sous l'URL http://sites.google.com/domainName/siteName/new-webpage-title et aurait l'en-tête de page "Nouveau titre de la page Web". Autrement dit, le titre est normalisé en new-webpage-title pour l'URL.
Pour personnaliser le chemin d'URL d'une page, vous pouvez définir la propriété page_name sur l'entrée de contenu. L'outil d'aide CreatePage() le fournit en tant qu'argument de mot clé facultatif.
Cet exemple crée une page filecabinet avec l'en-tête "Stockage de fichiers", mais crée la page sous l'URL http://sites.google.com/domainName/siteName/files (au lieu de http://sites.google.com/domainName/siteName/file-storage) en spécifiant la propriété page_name.
entry = client.CreatePage('filecabinet', 'File Storage', html='<b>HTML content</b>', page_name='files')
print 'Created. View it at: ' + entry.GetAlternateLink().href
Le serveur utilise les règles de priorité suivantes pour nommer le chemin de l'URL d'une page:
page_name, le cas échéant. Doit être conforme àa-z, A-Z, 0-9, -, _.title, ne doit pas être nul si le nom de la page n'est pas indiqué. La normalisation consiste à rogner et réduire les espaces blancs en "-" et à supprimer les caractères qui ne correspondent pas àa-z, A-Z, 0-9, -, _.
Créer des sous-pages
Pour créer des sous-pages (enfants) sous une page parente, utilisez l'argument de mot clé parent de CreatePage().
Le parent peut être un gdata.sites.gdata.ContentEntry ou une chaîne représentant l'ID personnel complet de l'entrée du contenu.
Cet exemple interroge le flux de contenu pour les éléments announcementpage et crée un élément announcement sous le premier trouvé:
uri = '%s?kind=%s' % (client.MakeContentFeedUri(), 'announcementpage')
feed = client.GetContentFeed(uri=uri)
entry = client.CreatePage('announcement', 'Party!!', html='My place, this weekend', parent=feed.entry[0])
print 'Posted!'
Importation des fichiers...
Tout comme dans Google Sites, l'API permet l'importation de pièces jointes vers un classeur ou une page parent. Les pièces jointes doivent être importées sur une page parente. Vous devez donc définir un lien parent sur le ContentEntry que vous essayez d'importer. Pour en savoir plus, consultez la section Créer des sous-pages.
La méthode UploadAttachment() de la bibliothèque cliente fournit une interface permettant d'importer des pièces jointes.
Importation des pièces jointes…
Dans cet exemple, un fichier PDF est importé dans le premier filecabinet trouvé dans le flux de contenu de l'utilisateur.
La pièce jointe est créée avec le titre "New Employee Handbook" (Manuel de l'employé) et la description (facultative) "HR package" (paquet de ressources humaines).
uri = '%s?kind=%s' % (client.MakeContentFeedUri(),'filecabinet')
feed = client.GetContentFeed(uri=uri)
attachment = client.UploadAttachment('/path/to/file.pdf', feed.entry[0], content_type='application/pdf',
title='New Employee Handbook', description='HR Packet')
print 'Uploaded. View it at: %s' % attachment.GetAlternateLink().href
Si l'importation réussit, attachment contient une copie de la pièce jointe créée sur le serveur.
Importer une pièce jointe dans un dossier
Les classeurs dans les dossiers de prise en charge de Google Sites UploadAttachment() fournit un argument de mot clé supplémentaire, folder_name, que vous pouvez utiliser pour importer une pièce jointe dans un dossier filecabinet. Indiquez simplement le nom de ce dossier:
import gdata.data
ms = gdata.data.MediaSource(file_path='/path/to/file.pdf', content_type='application/pdf')
attachment = client.UploadAttachment(ms, feed.entry[0], title='New Employee Handbook',
description='HR Packet', folder_name='My Folder')
Notez que cet exemple transmet un objet gdata.data.MediaSource à UploadAttachment() au lieu d'un chemin de fichier. Elle ne transmet pas non plus de type de contenu. Au lieu de cela, le type de contenu est spécifié dans l'objet MediaSource.
Pièces jointes Web
Les pièces jointes Web sont des types spéciaux de pièces jointes. Il s'agit essentiellement de liens vers d'autres fichiers sur le Web que vous pouvez ajouter à vos fiches filecabinet. Cette fonctionnalité est analogue à la méthode d 'importation Ajouter un fichier par URL dans l'interface utilisateur de Google Sites.
Remarque: Les pièces jointes Web ne peuvent être créées qu'avec un filecabinet. Elles ne peuvent pas être importées sur d'autres types de pages.
Cet exemple crée une pièce jointe Web sous le premier filecabinet trouvé dans le flux de contenu de l'utilisateur.
Son titre et sa description (facultative) sont définis respectivement sur "GoogleLogo" et "jolies couleurs".
uri = '%s?kind=%s' % (client.MakeContentFeedUri(),'filecabinet')
feed = client.GetContentFeed(uri=uri)
parent_entry = feed.entry[0]
image_url = 'http://www.google.com/images/logo.gif'
web_attachment = client.CreateWebAttachment(image_url, 'image/gif', 'GoogleLogo',
parent_entry, description='nice colors')
print 'Created!'
Cet appel crée un lien pointant vers l'image à l'adresse "http://www.google.com/images/logo.gif" dans le filecabinet.
Mettre à jour le contenu
Mettre à jour les métadonnées et/ou le contenu HTML d'une page
Les métadonnées (titre, pageName, etc.) et le contenu de la page de tout type d'entrée peuvent être modifiés à l'aide de la méthode Update() du client.
Vous trouverez ci-dessous un exemple de mise à jour d'un listpage avec les modifications suivantes:
- Le titre est remplacé par "Titre mis à jour".
- Le contenu HTML de la page a été remplacé par le "Contenu HTML mis à jour".
- Le premier en-tête de colonne de la liste est remplacé par "Propriétaire".
uri = '%s?kind=%s' % (client.MakeContentFeedUri(),'listpage') feed = client.GetContentFeed(uri=uri) old_entry = feed.entry[0] # Update the listpage's title, html content, and first column's name. old_entry.title.text = 'Updated Title' old_entry.content.html = 'Updated HTML Content' old_entry.data.column[0].name = 'Owner' # You can also change the page's webspace page name on an update. # old_entry.page_name = 'new-page-path' updated_entry = client.Update(old_entry) print 'List page updated!'
Remplacement du contenu et des métadonnées d'une pièce jointe
Vous pouvez remplacer le contenu d'une pièce jointe en créant un objet MediaSource avec le nouveau contenu du fichier et en appelant la méthode Update() du client. Les métadonnées de la pièce jointe (telles que le titre et la description) peuvent également être mises à jour, ou simplement les métadonnées.
Cet exemple montre comment mettre à jour simultanément le contenu et les métadonnées d'un fichier:
import gdata.data # Load the replacement content in a MediaSource. Also change the attachment's title and description. ms = gdata.data.MediaSource(file_path='/path/to/replacementContent.doc', content_type='application/msword') existing_attachment.title.text = 'Updated Document Title' existing_attachment.summary.text = 'version 2.0' updated_attachment = client.Update(existing_attachment, media_source=ms) print "Attachment '%s' changed to '%s'" % (existing_attachment.title.text, updated_attachment.title.text)
Suppression du contenu
Pour supprimer une page ou un élément d'un site Google, commencez par récupérer l'entrée de contenu, puis appelez la méthode Delete() du client.
client.Delete(content_entry)
Vous pouvez également transmettre le lien edit de l'entrée de contenu à la méthode Delete() et/ou forcer la suppression:
# force=True sets the If-Match: * header instead of using the entry's ETag. client.Delete(content_entry.GetEditLink().href, force=True)
Pour en savoir plus sur les ETag, consultez le guide de référence des API Google Data.
Téléchargement des pièces jointes
Chaque entrée attachment contient un lien src de contenu qui permet de télécharger le contenu du fichier.
Le client Sites contient une méthode d'assistance pour accéder au fichier et le télécharger à partir de ce lien: DownloadAttachment().
Il accepte un URI de téléchargement ou gdata.sites.data.ContentEntry pour son premier argument, ainsi qu'un chemin de fichier dans lequel enregistrer la pièce jointe en tant que deuxième argument.
Cet exemple extrait une entrée de pièce jointe particulière (en interrogeant son lien self) et télécharge le fichier vers le chemin d'accès spécifié:
uri = 'https://sites.google.com/feeds/content/site/siteName/1234567890' attachment = client.GetEntry(uri, desired_class=gdata.sites.data.ContentEntry) print "Downloading '%s', a %s file" % (attachment.title.text, attachment.content.type) client.DownloadAttachment(attachment, '/path/to/save/test.pdf') print 'Downloaded!'
Il appartient au développeur de l'application de spécifier une extension de fichier adaptée au type de contenu de la pièce jointe. Le type de contenu est indiqué dans entry.content.type.
Dans certains cas, vous ne pourrez peut-être pas télécharger le fichier sur le disque (par exemple, si votre application s'exécute dans Google App Engine).
Dans ces situations, utilisez _GetFileContent() pour récupérer le contenu du fichier et le stocker en mémoire.
Dans cet exemple, le téléchargement est une pièce jointe en mémoire.
try: file_contents = client._GetFileContent(attachment.content.src) # TODO: Do something with the file contents except gdata.client.RequestError, e: raise e
Flux LCA
Présentation des autorisations de partage (LCA)
Chaque entrée de la LCA du flux LCA représente un rôle d'accès accordé à une entité spécifique : un utilisateur, un groupe d'utilisateurs, un domaine ou l'accès par défaut (qui est un site public). Les entrées ne s'affichent que pour les entités disposant d'un accès explicite. Une seule entrée est affichée pour chaque adresse e-mail dans le panneau "Personnes disposant d'un accès" sur l'écran de partage de l'interface utilisateur de Google Sites. Ainsi, les administrateurs de domaine ne seront pas affichés, même s'ils ont un accès implicite à un site.
Rôles
L'élément de rôle représente un niveau d'accès qu'une entité peut avoir. Quatre valeurs sont possibles pour l'élément gAcl:role:
- lecteur : lecteur (équivalent à un accès en lecture seule)
- writer : collaborateur (équivalent à un accès en lecture/écriture).
- owner : en général l'administrateur du site (équivalent à un accès en lecture/écriture).
Niveaux d'accès
L'élément de champ d'application représente l'entité qui dispose de ce niveau d'accès. Il existe quatre types d'élément gAcl:scope:
- utilisateur : valeur d'adresse e-mail, par exemple "utilisateur@gmail.com".
- group : adresse e-mail d'un groupe Google (par exemple, "groupe@domaine.com").
- domaine : nom de domaine G Suite, par exemple "domaine.com".
- default : il n'existe qu'un seul champ d'application possible de type "default", qui n'a aucune valeur (par exemple,
<gAcl:scope type="default">). Ce champ d'application particulier contrôle l'accès de tout utilisateur par défaut sur un site public.
Remarque: Les domaines ne peuvent pas avoir de valeur gAcl:role définie sur l'accès "propriétaire". Ils ne peuvent être que des lecteurs ou des rédacteurs.
Récupérer le flux LCA
Le flux LCA permet de contrôler les autorisations de partage d'un site et peut être récupéré à l'aide de la méthode GetAclFeed().
L'exemple suivant extrait le flux LCA du site actuellement défini sur l'objet SitesClient et affiche les entrées d'autorisation:
print "Fetching acl permissions of site '%s'...\n" % client.site feed = client.GetAclFeed() for entry in feed.entry: print '%s (%s) - %s' % (entry.scope.value, entry.scope.type, entry.role.value)
Après une requête réussie, feed est un objet gdata.sites.data.AclFeed contenant une liste de gdata.sites.data.AclEntry.
Si vous travaillez avec des entrées dans le flux SiteFeed, chaque SiteEntry contient un lien vers son flux LCA.
Par exemple, l'extrait suivant extrait le premier site du flux "Site" de l'utilisateur et interroge son flux LCA:
feed = client.GetSiteFeed() site_entry = feed.entry[0] print "Fetching acl permissions of site '%s'...\n" % site_entry.site_name.text feed = client.GetAclFeed(uri=site_entry.FindAclLink())
Partager un site
Remarque: Certaines LCA de partage ne sont possibles que si le domaine est configuré pour autoriser de telles autorisations (par exemple, si le partage en dehors du domaine pour les domaines G Suite est activé, etc.).
Pour partager un site Google à l'aide de l'API, créez un gdata.sites.gdata.AclEntry avec les valeurs gdata.acl.data.AclScope et gdata.acl.data.AclRole souhaitées. Consultez la section Présentation des flux LCA pour connaître les valeurs AclScope et AclRoles possibles.
Cet exemple accorde des autorisations de lecture sur le site à l'utilisateur "utilisateur@example.com":
import gdata.acl.data scope = gdata.acl.data.AclScope(value='user@example.com', type='user') role = gdata.acl.data.AclRole(value='reader') acl = gdata.sites.gdata.AclEntry(scope=scope, role=role) acl_entry = client.Post(acl, client.MakeAclFeedUri()) print "%s %s added as a %s" % (acl_entry.scope.type, acl_entry.scope.value, acl_entry.role.value)
Partage au niveau du groupe et du domaine
Comme pour le partage d'un site avec un seul utilisateur, vous pouvez partager un site au sein d'un groupe Google ou d'un domaine G Suite. Les valeurs scope nécessaires sont listées ci-dessous.
Partage avec une adresse e-mail de groupe:
scope = gdata.acl.data.AclScope(value='group_name@example.com', type='group')
Partage avec un domaine entier:
scope = gdata.acl.data.AclScope(value='example.com', type='domain')
Le partage au niveau du domaine n'est possible que pour les domaines G Suite, et uniquement pour le domaine sur lequel le site est hébergé. Par exemple, http://sites.google.com/a/domaine1.com/siteA ne peut partager l'intégralité du site qu'avec domaine1.com, et non avec domaine2.com. Les sites qui ne sont pas hébergés sur un domaine G Suite (par exemple, http://sites.google.com/site/siteB) ne peuvent pas inviter de domaines.
Modifier les autorisations de partage
Pour une autorisation de partage existante sur un site, commencez par récupérer le AclEntry en question, modifiez l'autorisation comme vous le souhaitez, puis appelez la méthode Update() du client pour modifier la LCA sur le serveur.
Cet exemple modifie notre acl_entry précédent de la section Partager un site en remplaçant "utilisateur@example.com" par un rédacteur (collaborateur) :
acl_entry.role.value = 'writer' updated_acl = client.Update(acl_entry) # To force the update, even if you do not have the latest changes to the entry: # updated_acl = client.Update(acl_entrys, force=True)
Pour en savoir plus sur les ETag, consultez le guide de référence des API Google Data.
Suppression des autorisations de partage
Pour supprimer une autorisation de partage, commencez par récupérer AclEntry, puis appelez la méthode Delete() du client.
client.Delete(acl_entry)
Vous pouvez également transmettre à la méthode Delete() le lien edit de l'entrée LCA et/ou forcer la suppression:
# force=True sets the If-Match: * header instead of using the entry's ETag. client.Delete(acl_entry.GetEditLink().href, force=True)
Pour en savoir plus sur les ETag, consultez le guide de référence des API Google Data.
Sujets spéciaux
Récupérer un flux ou une entrée
Si vous souhaitez récupérer un flux ou une entrée que vous avez déjà récupéré, vous pouvez améliorer l'efficacité en indiquant au serveur de n'envoyer la liste ou l'entrée que si elle a été modifiée depuis la dernière fois que vous l'avez récupérée.
Pour effectuer ce type de récupération conditionnelle, transmettez une valeur ETag à GetEntry(). Par exemple, si vous aviez un objet entry existant:
import gdata.client try: entry = client.GetEntry(entry.GetSelfLink().href, desired_class=gdata.sites.data.ContentEntry, etag=entry.etag) except gdata.client.NotModified, error: print 'You have the latest copy of this entry' print error
Si GetEntry() génère l'exception gdata.client.NotModified, l'ETag de l'entrée correspond à la version sur le serveur, ce qui signifie que vous disposez de la copie la plus récente.
Toutefois, si un autre client/utilisateur a apporté des modifications, la nouvelle entrée est renvoyée dans entry et aucune exception n'est générée.
Pour en savoir plus sur les ETag, consultez le guide de référence des API Google Data.