Important:Ce document a été rédigé avant 2012. Options d'authentification décrits dans ce document (OAuth 1.0, AuthSub et ClientLogin) ont été officiellement abandonné 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 ; Si vous avez besoin d'aide pour configurer la bibliothèque cliente, consultez Premiers pas avec la bibliothèque cliente Python Google Data Si vous êtes intéressé par 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 Google Sites, consultez la guide du protocole.
Audience
Ce document est destiné aux développeurs qui souhaitent développer des applications clientes qui interagissent 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+ et des modules répertoriés sur la page wiki DependencyModules. Après avoir téléchargé la bibliothèque cliente, Consultez la page Premiers pas avec la bibliothèque Google Data Python pour obtenir de l'aide sur l'installation et l'utilisation du client.
Exécuter l'exemple
Un exemple fonctionnel complet se trouve 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 invitera à saisir ces valeurs. L'exemple permet à l'utilisateur d'effectuer un certain nombre d'opérations comment utiliser l'API Google Sites classique. Par conséquent, vous devrez vous authentifier pour effectuer certaines opérations (par exemple, pour modifier du contenu). Le programme vous invitent é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 devrez également configurer un objet SitesClient, qui représente une connexion client à l'API Google Sites classique.
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 utiliser 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
Utilisez le format suivant: company-applicationname-version
Remarque: Le reste du guide suppose que vous avez créé un objet SitesClient dans la variable client.
S'authentifier auprès de 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 à des données privées et publiques flux, 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 un site public sans y apporter de mises à jour (ce qui nécessite un client authentifié). Pour ce faire, utilisez Authentification par nom d'utilisateur/mot de passe ClientLogin, AuthSub ou OAuth.
Pour en savoir plus sur AuthSub, OAuth et ClientLogin, consultez la 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 d'un compte 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. Il lui suffit Veuillez indiquer un jeton AuthSub.
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 dirigeant l'utilisateur
à la page d'approbation AuthSub pour authentifier l'utilisateur et lui demander l'accès à ses documents. La bibliothèque cliente Python
Google Data fournit une fonction,
generate_auth_sub_url() pour générer cette URL. Le code ci-dessous configure 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 la
AuthSubRequest):
- L'URL suivante (URL vers laquelle Google redirigera les internautes)
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 : valeur booléenne indiquant si le jeton sera utilisé en mode sécurisé et enregistré ou non ;
Truedans l'exemple ci-dessus - session : deuxième valeur booléenne indiquant si le jeton à usage unique sera ultérieurement échangé contre un jeton de session ou non.
Truedans l'exemple ci-dessus
Passer à un jeton de session
Consultez la page Utiliser AuthSub avec les bibliothèques clientes de l'API Google Data.
Récupérer des informations sur un jeton de session
Consultez la page Utiliser AuthSub avec les bibliothèques clientes de l'API Google Data.
Révoquer un jeton de session
Consultez la page Utiliser AuthSub avec les bibliothèques clientes de l'API Google Data.
Conseil: Une fois que votre application a acquis un jeton de sessions de longue durée,
stocker ce jeton dans votre base de données
afin de le rappeler pour une utilisation ultérieure. Il n'est pas nécessaire de renvoyer l'utilisateur vers AuthSub à chaque exécution de votre application.
Utilisez client.auth_token = gdata.gauth.AuthSubToken(TOKEN_STR) pour définir un jeton existant sur le client.
OAuth pour le Web ou les applications installées/mobiles
OAuth peut être utilisé à la place d'AuthSub et est destiné aux applications Web. OAuth revient à utiliser le mode enregistré et sécurisé d'AuthSub. car toutes les demandes 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
Récupérer un jeton de requête
Consultez la page Utiliser OAuth avec les bibliothèques clientes de l'API Google Data.
Autoriser un jeton de requête
Consultez la page Utiliser OAuth avec les bibliothèques clientes de l'API Google Data.
Passer à un jeton d'accès
Consultez la page Utiliser OAuth avec les bibliothèques clientes de l'API Google Data.
Conseil: Une fois que votre application a acquis un jeton d'accès OAuth,
stocker ce jeton dans votre base de données
afin de 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 de comptes Google. Lors de la première exécution, votre application invite l'utilisateur à saisir son nom d'utilisateur et son mot de passe. Dans les requêtes ultérieures, 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ée de
GDClient Spécifiez l'adresse e-mail et
le mot de passe de l'utilisateur au nom duquel votre client envoie les 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 votre application a authentifié l'utilisateur pour la première fois, stockez le jeton d'authentification dans votre base de données afin de 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 votre 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 de l'API Google Data.
Flux d'actualisation
Le flux de sites peut être utilisé pour répertorier les sites Google Sites d'un utilisateur ou pour lesquels il dispose d'autorisations d'affichage. 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 copier un l'intégralité du 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 accepte un attribut
uri, que vous pouvez utiliser pour spécifier un URI de flux de site alternatif. Par défaut, le GetSiteFeed()
utilise le nom de site et le domaine
définis sur l'objet client. Consultez la section Premiers pas pour en savoir plus
plus d'informations sur la définition de ces valeurs sur votre objet client.
Voici un exemple de récupération de la liste des 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 et le nom du site à partir duquel il a été copié, ainsi que l'URI du flux de la LCA correspondante.
Création de 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 une
l'argument facultatif uri, que vous pouvez utiliser pour spécifier un URI de flux de site alternatif (dans le cas de la création
le site sous un domaine différent de celui défini dans votre objet SitesClient).
Voici un exemple de création d'un site dont le thème est "slate" et en fournissant une titre et 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 demande ci-dessus crée un site sous le domaine G Suite example2.com.
Ainsi, l'URL du site se présentera comme suit : https://sites.google.com/a/example2.com/titre-pour-mon-site.
Si le site a bien été créé, le serveur renvoie une réponse gdata.sites.data.SiteEntry
contenant les éléments ajoutés par le serveur: un lien vers le site, un lien vers le flux des 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() permet également de copier un site existant. Pour ce faire, transmettez l'argument de mot clé source_site.
Tous les sites copiés contiennent 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 les modèles de site appartenant à l'utilisateur authentifié peuvent être copiés.
- Un modèle de site peut également être copié. Un site est utilisé comme modèle si la case "Publier ce site comme modèle" est coché sur la page des paramètres de Google Sites.
- Vous pouvez copier un site d'un autre domaine, tant que vous n'êtes pas indiqué comme propriétaire du site source.
Mettre à jour les métadonnées d'un site
Pour mettre à jour le titre ou le résumé d'un site, vous avez besoin d'un SiteEntry contenant le site en question. Ce
L'exemple utilise la méthode GetEntry() pour récupérer d'abord un élément SiteEntry, puis modifier son titre, sa description et son tag 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é...
Remarque: Pour accéder à ce flux, vous devez être collaborateur ou propriétaire du site. Votre client doit s'authentifier à l'aide d'un jeton AuthSub, OAuth ou ClientLogin. Consultez la section S'authentifier auprès du service Sites.
Vous pouvez récupérer l'activité récente (modifications) d'un site en récupérant le flux d'activités.
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
d'une modification apportée au Site.
Récupération de l'historique des révisions
Remarque: Pour accéder à ce flux, vous devez être collaborateur ou propriétaire du site. Votre client doit s'authentifier à l'aide d'un jeton AuthSub, OAuth ou ClientLogin. Consultez la section S'authentifier auprès du service Sites.
Le flux des révisions fournit des informations sur l'historique des révisions pour chaque entrée de contenu. GetRevisionFeed()
peut être utilisée pour récupérer les révisions d'une entrée de contenu donnée. Cette méthode accepte un uri facultatif
qui accepte un gdata.sites.data.ContentEntry, l'URI complet d'une entrée de contenu ou un ID d'entrée de contenu.
Cet exemple 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
à cette révision, le numéro de version et la date de création de la nouvelle version.
Flux de contenu
Récupérer le flux de contenu
Remarque: Le flux de contenu peut nécessiter ou non une authentification. selon les autorisations de partage du site. Si le site n'est pas public, votre client doit s'authentifier à l'aide d'un jeton AuthSub, OAuth ou ClientLogin. Voir S'authentifier auprès du service Sites
Le flux de contenu renvoie le contenu le plus récent d'un site. Il est accessible en appelant la bibliothèque
La méthode GetContentFeed(), qui accepte un paramètre de chaîne uri facultatif pour transmettre
une requête personnalisée.
Voici un exemple d'extraction de l'intégralité du flux de contenu et d'impression d'é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.
sur gdata.sites.data.ContentEntry. Chaque entrée représente une page ou un élément différent dans
site de l'utilisateur et comporte des éléments spécifiques au type d'entrée. Consultez l'exemple d'application pour mieux comprendre
de certaines des propriétés
disponibles dans chaque genre d'entrée.
Exemples de requêtes de 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 celles spécifiques à l'API Google Sites classique. Pour obtenir des informations plus détaillées et la liste complète des paramètres pris en charge, consultez la 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 genres d'entrées spécifiques
Pour ne récupérer qu'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 kind par une virgule. Par exemple, cet extrait renvoie filecabinet et
listpage entrées:
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 son chemin d'accès
Si vous connaissez le chemin relatif d'une page du site Google, vous pouvez utiliser le paramètre path pour explorer cette page en particulier.
Cet exemple renverrait la page située à l'adresse
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 autres paramètres, consultez le guide de référence.
Création de contenu
Remarque:Avant de créer le contenu d'un site, assurez-vous de l'avoir configuré dans le client.client.site = "siteName"
Vous pouvez créer du contenu (pages Web, pages de liste, 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éation de nouveaux éléments / pages
Cet exemple crée un élément webpage sous le niveau supérieur, inclut du code XHTML pour le corps de la page,
et définit le titre de l'en-tête sur "Nouveau titre de la page Web" :
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 qui est renseigné lors de la création (par exemple, un listpage avec des en-têtes de colonne), vous devez créer
gdata.sites.data.ContentEntry manuellement, renseignez les propriétés qui vous intéressent, puis appelez client.Post().
Créer des articles/pages sous des chemins d'URL personnalisées
Par défaut, l'exemple précédent est créé sous l'URL
http://sites.google.com/domainName/siteName/new-webpage-title et
avoir pour en-tête "Nouveau titre de la page Web". Autrement dit, le titre est normalisé en new-webpage-title pour l'URL.
Pour personnaliser le chemin de l'URL d'une page, vous pouvez définir la propriété page_name sur l'entrée de contenu. L'outil d'aide CreatePage()
l'indique en tant qu'argument de mot clé facultatif.
Cet exemple crée une page filecabinet avec l'en-tête "File Storage" (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 d'URL d'une page:
page_name, le cas échéant. Doit respecter lesa-z, A-Z, 0-9, -, _.titlene doit pas être nulle si le nom de la page n'est pas indiqué. La normalisation consiste à supprimer et réduire les espaces blancs sur "-" 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 soit un gdata.sites.gdata.ContentEntry, soit une chaîne représentant le
l'identifiant complet de l'entrée du contenu.
Cet exemple interroge le flux de contenu sur les announcementpage et crée un 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!'
Importer des fichiers
Tout comme dans Google Sites, l'API permet d'importer des pièces jointes dans un classeur ou une page parente. Vous devez importer les pièces jointes
à une page parent. 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 l'interface permettant d'importer des pièces jointes.
Transfert de pièces jointes
Cet exemple importe un fichier PDF dans le premier élément filecabinet trouvé dans le flux de contenu de l'utilisateur.
La pièce jointe est créée avec le titre "New Employee Handbook" (Manuel du nouveau personnel). et une description (facultative) : "Paquet RH".
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.
Importation d'une pièce jointe dans un dossier
Les classements de Google Sites peuvent prendre en charge des dossiers. Le UploadAttachment() fournit un mot clé supplémentaire
l'argument 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() à la place.
d'un chemin de fichier. Il ne transmet pas non plus de type de contenu. Le type de contenu est spécifié dans l'objet MediaSource.
Pièces jointes Web
Les pièces jointes Web sont des types de pièces jointes particuliers. Ce sont des liens vers d'autres fichiers sur le Web
que vous pouvez ajouter à vos fiches filecabinet. Cette fonctionnalité est semblable à l'option Ajouter un fichier à l'aide d'une URL. dans l'interface utilisateur de Google Sites.
Remarque: Les pièces jointes Web ne peuvent être créées qu'à partir d'un filecabinet. Vous ne pouvez pas les importer vers d'autres types de pages.
Dans cet exemple, une pièce jointe Web est créée sous le premier élément filecabinet trouvé dans le flux de contenu de l'utilisateur.
Son titre et sa description (facultative) sont définis sur "GoogleLogo". et « jolies couleurs », respectivement.
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!'
L'appel crée un lien pointant vers l'image sur "http://www.google.com/images/logo.gif" dans filecabinet.
Mise à jour du contenu
Mise à jour des métadonnées et/ou du contenu HTML d'une page
Les métadonnées (title, 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'une listpage avec les modifications suivantes:
- Le titre est remplacé par "Titre mis à jour".
- Le contenu HTML de la page est remplacé par "Contenu HTML mis à jour"
- L'en-tête de la première 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!'
Remplacer le contenu et les 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 contenu du nouveau fichier et en appelant la méthode Update() du client. La pièce jointe
les métadonnées (comme le titre et la description) peuvent également être modifiées, ou simplement les métadonnées.
Cet exemple illustre la mise à jour simultanée du contenu et des 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 de 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 à la méthode Delete() le lien edit de l'entrée de contenu 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 ETags, 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 de contenu src 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 du lien suivant: DownloadAttachment().
Elle accepte un URI gdata.sites.data.ContentEntry ou de téléchargement pour son premier argument, ainsi qu'un chemin d'accès pour enregistrer la pièce jointe.
comme seconde.
Cet exemple extrait une entrée de pièce jointe particulière (en interrogeant son lien self) et télécharge le fichier au chemin 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. Type de contenu
se trouve dans entry.content.type.
Dans certains cas, vous ne pourrez peut-être pas télécharger le fichier sur le disque (si votre application s'exécute dans Google App Engine, par exemple).
Dans ces situations, utilisez _GetFileContent() pour récupérer le contenu du fichier et le stocker en mémoire.
Cet exemple de téléchargement est une pièce jointe à la 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 LCA représente un rôle d'accès attribué à 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 s'affiche. pour chaque adresse e-mail de la liste des personnes ayant accès dans 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 du rôle représente le niveau d'accès qu'une entité peut avoir. L'élément gAcl:role peut avoir quatre valeurs:
- reader : lecteur (équivalent de l'accès en lecture seule).
- writer : collaborateur (équivalent à l'accès en lecture/écriture).
- propriétaire : généralement l'administrateur du site (qui équivaut à un accès en lecture/écriture).
Niveaux d'accès
L'élément du champ d'application représente l'entité disposant de ce niveau d'accès. Il existe quatre types d'éléments gAcl:scope possibles:
- utilisateur : valeur d'adresse e-mail, par exemple "utilisateur@gmail.com".
- groupe : 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 contrôle l'accès par défaut à tout utilisateur sur un site public.
Remarque: Les domaines ne peuvent pas avoir de valeur gAcl:role.
défini sur "owner" (propriétaire) accès, ils ne peuvent être
que lecteurs ou rédacteurs.
Récupérer le flux LCA
Le flux LCA peut être utilisé pour 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 récupère 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 sera un objet gdata.sites.data.AclFeed contenant
une fiche gdata.sites.data.AclEntry.
Si vous travaillez avec des entrées dans le SiteFeed, chaque SiteEntry contient un lien vers son flux LCA.
Par exemple, l'extrait de code suivant extrait le premier site du flux de 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 accorder ces autorisations (par exemple, si le partage en dehors du domaine est activé pour les domaines G Suite, etc.).
Pour partager un site Google à l'aide de l'API, créez un gdata.sites.gdata.AclEntry avec l'adresse e-mail
Valeurs gdata.acl.data.AclScope et gdata.acl.data.AclRole. Consultez le
Section Présentation du flux LCA pour la AclScope possible
et AclRoles.
L'exemple suivant 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
De la même manière que pour partager un site avec un seul utilisateur, vous pouvez partager un site sur une
groupe Google ou domaine G Suite. Les valeurs scope nécessaires sont listées ci-dessous.
Partage avec l'adresse e-mail d'un groupe:
scope = gdata.acl.data.AclScope(value='group_name@example.com', type='group')
Partage avec l'ensemble d'un domaine:
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/domain1.com/siteA peut seulement partager l'intégralité du site avec domain1.com, et non domain2.com. Les sites qui 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.
Modification des autorisations de partage
Pour une autorisation de partage existante sur un site, récupérez d'abord l'AclEntry en question, puis modifiez l'autorisation
puis appelez la méthode Update() du client pour modifier la LCA sur le serveur.
Cet exemple modifie le acl_entry précédent de la section Partager un site,
en modifiant "utilisateur@example.com" pour être écrivain (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 ETags, 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 de la 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 ETags, 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 déjà récupérés, vous pouvez gagner en efficacité en indiquant au serveur d'envoyer la liste ou l'entrée uniquement 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, la méthode
L'ETag correspond à la version du 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 ne sera générée.
Pour en savoir plus sur les ETags, consultez le guide de référence des API Google Data.