Questa pagina è stata tradotta dall'API Cloud Translation.

Guida per gli sviluppatori: Python

L'API Blogger Data consente alle applicazioni client di visualizzare e aggiornare i contenuti di Blogger sotto forma di feed dell'API dati di Google.

L'applicazione client può utilizzare l'API di dati di Blogger per creare nuovi post del blog, modificare o eliminare i post del blog esistenti e fare query per post di blog che corrispondono a criteri specifici.

Oltre a fornire alcune informazioni sulle funzionalità dell'API di dati di Blogger, questo documento fornisce esempi di interazioni di base di API di dati utilizzando la libreria client di Python. Se ti interessa saperne di più sul protocollo sottostante utilizzato dalla libreria, consulta la sezione sul protocollo della guida di questo sviluppatore.

Contenuti

Pubblico

Questo documento è destinato ai programmatori che vogliono scrivere applicazioni client Python in grado di interagire con Blogger.

Questo documento presuppone che tu abbia compreso le idee generali alla base del protocollo API di dati di Google.

Per informazioni di riferimento generali sull'API di dati di Blogger, consulta la guida di riferimento del protocollo.

Per cominciare

Per assistenza sulla configurazione della libreria client, consulta la Guida introduttiva.

La libreria client Python richiede Python 2.2 o versioni successive. Dopo aver scaricato la libreria client, dovrai anche scaricare e installare il pacchetto ElementTree.

Creazione di un account Blogger

Ti consigliamo di creare un account Blogger per scopi di test. Blogger utilizza gli Account Google pertanto, se hai già un Account Google, non devi fare altro.

Eseguire il codice campione

Un client di esempio completo funzionante, contenente tutto il codice di esempio mostrato in questo documento, è disponibile nel file BloggerExample.py, nella directory gdata-python-client/samples/blogger/.

Il client di esempio esegue diverse operazioni sul blog fornito per dimostrare l'uso dell'API Blogger Data.

Puoi eseguire l'esempio con i seguenti argomenti:

python BloggerExample.py --email [email_address] --password [password]

Per utilizzare gli esempi in questo documento nel tuo codice, devi disporre delle seguenti istruzioni import:

from gdata import service
import gdata
import atom

Autenticazione al servizio Blogger

Puoi accedere ai feed pubblici e privati utilizzando l'API dei dati di Blogger. I feed pubblici non richiedono alcuna autenticazione, ma sono di sola lettura. Se vuoi modificare i blog, il tuo cliente deve eseguire l'autenticazione prima di richiedere i feed privati. Può eseguire l'autenticazione utilizzando uno dei tre approcci seguenti:autenticazione OAuth, autenticazione proxy AuthSub o autenticazione nome utente/password ClientLogin.

Per ulteriori informazioni sull'autenticazione con le API di dati di Google in generale, consulta la documentazione sull'autenticazione.

La maggior parte degli esempi nelle sezioni successive di questo documento presuppone che tu abbia un'istanza GDataService autenticata.

Autenticazione OAuth

Per la documentazione sull'autenticazione OAuth utilizzando la libreria GData Python, consulta OAuth nelle librerie client del protocollo Google Data.

Autenticazione proxy AuthSub

L'autenticazione del proxy AuthSub viene utilizzata dalle applicazioni web che devono autenticare gli utenti negli Account Google. L'operatore del sito web e il codice client non hanno accesso al nome utente e alla password dell'utente di Blogger; il client invece riceve token AuthSub speciali che consentono al client di agire per conto di un determinato utente. Per informazioni più dettagliate, consulta la documentazione di AuthSub.

Quando un utente visita per la prima volta la tua applicazione, non è ancora stato autenticato. In questo caso, devi visualizzare alcune informazioni e un link che indirizza l'utente a una pagina Google per autenticare la richiesta di accesso ai suoi blog. La libreria client Python fornisce una funzione per generare l'URL della pagina Google. Il codice seguente recupera l'URL della pagina AuthSubRequest:

def GetAuthSubUrl():
  next = 'http://www.example.com/welcome.pyc'
  scope = 'http://www.blogger.com/feeds/'
  secure = False
  session = True
  blogger_service = service.GDataService()
  return blogger_service.GenerateAuthSubURL(next, scope, secure, session);

authSubUrl = GetAuthSubUrl();
print '<a href="%s">Login to your Google account</a>' % authSubUrl

Il metodo GenerateAuthSubURL accetta i seguenti parametri (corrispondenti ai parametri di ricerca utilizzati dal gestore AuthSubRequest):

avanti: L'URL della pagina a cui Google deve reindirizzare l'utente dopo l'autenticazione.
ambito: Indica che l'applicazione richiede un token per accedere ai feed di Blogger. La stringa dell'ambito da utilizzare è http://www.blogger.com/feeds/ (con codifica URL, ovviamente).
sicuro: Indica se il client richiede un token sicuro.
sessione: Indica se il token restituito può essere scambiato con un token multiuso (sessione).

L'esempio precedente mostra una chiamata che non richiede un token sicuro (il valore di secure è False). L'URL della richiesta risultante potrebbe essere simile al seguente:

https://www.google.com/accounts/AuthSubRequest?scope=http%3A%2F%2Fwww.blogger.com%2Ffeeds%2F&session=1&secure=0&next=http%3A%2F%2Fwww.example.com%2Fwelcome.pyc

L'utente segue il link al sito di Google e autentica il proprio Account Google.

Dopo l'autenticazione dell'utente, il sistema AuthSub li reindirizza all'URL specificato nel parametro di ricerca next dell'URL AuthSubRequest. Il sistema AuthSub aggiunge un token di autenticazione all'URL, come valore del parametro di ricerca token. Ad esempio:

http://www.example.com/welcome.pyc?token=yourAuthToken

Esistono diversi modi per recuperare il valore del token dall'URL, ad esempio:

import cgi

parameters = cgi.FieldStorage()
authsub_token = parameters['token']

Questo valore token rappresenta un token AuthSub monouso. In questo esempio, poiché session = True è stato specificato, è possibile scambiare questo token con un token di sessione AuthSub utilizzando il metodo UpgradeToSessionToken, che chiama il servizio AuthSubSessionToken:

blogger_service = service.GDataService()
blogger_service.auth_token = authsub_token
blogger_service.UpgradeToSessionToken()

In altre parole, trasmetti il tuo token monouso al metodo UpgradeToSessionToken e l'interfaccia AuthSub restituisce un token di sessione.

L'applicazione può quindi utilizzare il valore del token della sessione nelle interazioni successive con Blogger. La libreria client invia automaticamente il token insieme alle richieste.

Autenticazione nome utente/password ClientLogin

Utilizza l'autenticazione ClientLogin se il client è un client autonomo, "singolo" per utente singolo (come un'applicazione desktop). Richiama il metodo ProgrammaticLogin() nella tua istanza GDataService e tutte le interazioni successive con Blogger verranno autenticate:

blogger_service = service.GDataService('user@example.com', 'secretPassword')
blogger_service.source = 'exampleCo-exampleApp-1.0'
blogger_service.service = 'blogger'
blogger_service.account_type = 'GOOGLE'
blogger_service.server = 'www.blogger.com'
blogger_service.ProgrammaticLogin()

Nello snippet riportato sopra, impostiamo tre proprietà nell'istanza GDataService. Il primo è il nome della nostra applicazione nel formato companyName-applicationName-versionID. Il secondo è il nome del servizio con cui vogliamo interagire; la terza è l'indirizzo del server.

Tieni presente che account_type è esplicitamente impostato su GOOGLE. Se non imposti questo parametro, gli utenti di G Suite non potranno utilizzare correttamente l'API Blogger.

Per ulteriori informazioni sull'autenticazione ClientLogin, incluse le richieste e le risposte di esempio, consulta la documentazione sull'autenticazione per le applicazioni installate.

Nota: utilizza lo stesso token per tutte le richieste in una determinata sessione; non acquisire un nuovo token per ogni richiesta di Blogger.

Nota: come descritto nella documentazione di ClientLogin, la richiesta di autenticazione potrebbe non riuscire e richiedere una verifica CAPTCHA. Se vuoi che Google emetta e gestisca la verifica CAPTCHA, invia l'utente a https://www.google.com/accounts/DisplayUnlockCaptcha?service=blogger (anziché all'URL di gestione CAPTCHA fornito nella documentazione ClientLogin).

Recupero di un elenco di blog in corso...

L'API di dati di Blogger fornisce un feed che elenca i blog per un determinato utente; tale feed è noto come "metafeed".

Il codice di esempio seguente utilizza un'istanza GDataService autenticata per recuperare il metafeed, quindi stampa il titolo di ogni blog.

def PrintUserBlogTitles(blogger_service):
  query = service.Query()
  query.feed = '/feeds/default/blogs'
  feed = blogger_service.Get(query.ToUri())

  print feed.title.text
  for entry in feed.entry:
    print "\t" + entry.title.text

Prendi nota dell'URL utilizzato dal metodo Get. Questo è l'URL predefinito del metafeed, che restituisce un elenco di blog per l'utente attualmente autenticato. Per accedere a un feed per un altro utente, puoi inserire l'ID dell'utente al posto di default nell'URL del metafeed. L'ID utente è la stringa di cifre che si trova alla fine dell'URL del profilo dell'utente.

Lo snippet di codice riportato di seguito illustra come estrarre un ID blog dal feed. Avrai bisogno dell'ID blog per eseguire operazioni di creazione, aggiornamento ed eliminazione su post e commenti. Lo snippet riportato di seguito sceglie il primo blog recuperato per un utente.

blog_id = feed.entry[0].GetSelfLink().href.split("/")[-1]

Nell'esempio BloggerExample.py viene creata una classe BloggerExample e l'ID blog è impostato nel costruttore per potervi accedere facilmente in un secondo momento. Per la maggior parte degli esempi riportati di seguito in questo documento, blog_id viene passato come variabile.

Creazione di post

L'API Blogger Data consente di creare e pubblicare nuove voci di blog, nonché di creare bozze di voci.

Nota: l'impostazione di un autore personalizzato per i post non è attualmente supportata. Tutti i nuovi post verranno visualizzati come se fossero stati creati dall'utente attualmente autenticato.

Pubblicare un post del blog

Puoi utilizzare la libreria client Python per pubblicare nuove voci del blog.

Per prima cosa, crea un'istanza GDataEntry per rappresentare il post del blog. Quindi, potrai impostare il titolo, i contenuti e altri attributi del post del blog. Infine, usa l'istanza GDataService per inserire il post. Ecco un esempio di come pubblicare un nuovo post del blog:

def CreatePublicPost(blogger_service, blog_id, title, content):
  entry = gdata.GDataEntry()
  entry.title = atom.Title('xhtml', title)
  entry.content = atom.Content(content_type='html', text=content)
  return blogger_service.Post(entry, '/feeds/%s/posts/default' % blog_id)

blogEntry = CreatePublicPost(blogger_service, blog_id,
    title='I have the answer', content='Eureka! It is 42!')

Creazione di una bozza di post del blog

Le bozze dei post vengono create come i post pubblici, ma devi impostare l'elemento dell'estensione draft nell'istanza GDataEntry. Il blog post di cui sopra potrebbe essere creato come bozza aggiungendo le righe evidenziate:

def CreateDraftPost(blogger_service, blog_id, title, content):
  entry = gdata.GDataEntry()
  entry.title = atom.Title('xhtml', title)
  entry.content = atom.Content(content_type='html', text=content)

  control = atom.Control()
  control.draft = atom.Draft(text='yes')
  entry.control = control

  return blogger_service.Post(entry, '/feeds/%s/posts/default' % blog_id)

draftEntry = CreateDraftPost(blogger_service, blog_id,
    title='I have the question',
    content='What do you get if you multiply six by nine?')

Per trasformare una bozza di post di blog esistente in un post pubblicato, recupera la bozza, imposta l'attributo bozza su no, quindi aggiorna il post. Parleremo del recupero e dell'aggiornamento dei post nelle prossime sezioni.

Recupero dei post in corso...

Le seguenti sezioni descrivono come recuperare un elenco di post del blog, con e senza parametri di ricerca.

Puoi eseguire query su un feed pubblico di Blogger senza autenticazione. quindi non devi impostare le credenziali o eseguire l'autenticazione AuthSub prima di recuperare i post da un blog pubblico.

Recupero di tutti i post del blog in corso...

Per recuperare i post dell'utente, richiama il metodo GetFeed con l'URL del feed post del blog:

def PrintAllPosts(blogger_service, blog_id):
  feed = blogger_service.GetFeed('/feeds/' + blog_id + '/posts/default')

  print feed.title.text
  for entry in feed.entry:
    print "\t" + entry.title.text
    print "\t" + entry.content.text
    print "\t" + entry.updated.text
  print

Recupero dei post mediante parametri di ricerca

L'API di dati di Blogger consente di richiedere un set di voci che corrispondono a criteri specifici, come la richiesta di post del blog pubblicati o aggiornati in un determinato intervallo di date. Per farlo, devi creare un'istanza Query, quindi chiamare il metodo Get().

Ad esempio, per inviare una query sull'intervallo di date, imposta le proprietà published_min e published_min dell'istanza Query. Il seguente snippet di codice stampa il titolo e i contenuti di ogni post del blog pubblicato tra l'ora di inizio e quella di fine specificate:

def PrintPostsInDateRange(blogger_service, blog_id, start_time='2007-04-01', end_time='2007-04-25'):
  query = service.Query()
  query.feed = '/feeds/' + blog_id + '/posts/default'
  query.published_min = start_time
  query.published_max = end_time
  feed = blogger_service.Get(query.ToUri())

  print feed.title.text + " posts between " + start_time + " and " + end_time
  for entry in feed.entry:
    print "\t" + entry.title.text
    print "\t" + entry.content.text
    print "\t" + entry.updated.text
  print

Noterai che l'oggetto Query viene creato utilizzando lo stesso URL del feed post utilizzato per recuperare i post.

L'API di dati di Blogger supporta le seguenti proprietà Query:

categorie: Specifica le categorie (note anche come etichette) per filtrare i risultati del feed. Ad esempio, http://www.blogger.com/feeds/blogID/posts/default/-/Fritz/Laurie restituisce le voci con le etichette Fritz e Laurie. Per specificare la query di categoria nella libreria client Python, puoi utilizzare query.categories = ['Fritz','Laurie',]
max_risultati: Il numero massimo di voci da restituire.
abbiano_pubblicato,_pubblicazione_max: I limiti per le date di pubblicazione delle iscrizioni.
indice_inizio: L'indice in base uno del primo risultato da recuperare (per il paging).
updated_min, updated_max: I limiti per le date di aggiornamento delle voci. Questi parametri di ricerca vengono ignorati a meno che il parametro orderby non sia impostato su updated.

Per ulteriori informazioni sui parametri di ricerca, consulta la Guida di riferimento API per i dati di Blogger e la Guida di riferimento per le API di dati Google.

Aggiornamento dei post in corso...

Per aggiornare un post del blog esistente, devi prima recuperare la voce che vuoi aggiornare, quindi modificarla, quindi inviarla a Blogger utilizzando il metodo Put. Lo snippet di codice riportato di seguito modifica il titolo di una voce di blog, supponendo che tu abbia già recuperato la voce dal server.

def UpdatePostTitle(blogger_service, entry_to_update, new_title='The REAL answer'):
  entry_to_update.title = atom.Title('xhtml', new_title)
  return blogger_service.Put(entry_to_update, entry_to_update.GetEditLink().href)

Il codice sopra riportato restituisce un elemento GDataEntry che contiene l'intero post appena aggiornato. Per aggiornare eventuali altre proprietà, è sufficiente impostarle nell'istanza GDataEntry prima di chiamare Put.

Nota: la modifica dei dati dell'autore associati ai post non è attualmente supportata.

Eliminazione dei post in corso...

Per eliminare un post, passa l'URL di modifica del post al metodo Delete nell'oggetto GDataService, in questo modo:

def DeletePost(blogger_service, edit_link_href):
  blogger_service.Delete(edit_link_href)

Commenti

L'API Blogger Data consente di creare, recuperare ed eliminare i commenti. L'aggiornamento dei commenti non è supportato (né è disponibile nell'interfaccia web).

Creazione di commenti

Per pubblicare un commento, crea un oggetto GDataEntry e inseriscilo come segue:

def CreateComment(blogger_service, blog_id, post_id, comment_text='Mostly harmless'):
  feed_uri = '/feeds/' + blog_id + '/' + post_id + '/comments/default'

  entry = gdata.GDataEntry()
  entry.content = atom.Content(content_type='xhtml', text=comment_text)
  return blogger_service.Post(entry, feed_uri)

Nota: al momento puoi pubblicare commenti solo su un blog di proprietà dell'utente autenticato.

Nota: l'impostazione di un autore personalizzato per i commenti non è attualmente supportata. Tutti i nuovi commenti appariranno come se fossero stati creati dall'utente attualmente autenticato.

Recupero dei commenti in corso...

Puoi recuperare i commenti relativi a un determinato post dall'URL del feed dei commenti del post:

def PrintAllComments(blogger_service, blog_id, post_id):
  feed_url = '/feeds/' + blog_id + '/' + post_id + '/comments/default'
  feed = blogger_service.Get(feed_url)

  print feed.title.text
  for entry in feed.entry:
    print "\t" + entry.title.text
    print "\t" + entry.updated.text
  print

In alternativa, puoi ottenere i commenti da tutti i post utilizzando l'URL del feed dei commenti del blog:

http://www.blogger.com/feeds/blogID/comments/default

Eliminazione commenti

Per eliminare un commento, passa l'URL di modifica del commento al metodo Delete sul tuo oggetto GDataService in questo modo:

def DeleteComment(blogger_service, post_id, comment_id):
  feed_url = '/feeds/' + post_id + '/comments/default/' + comment_id
  blogger_service.Delete(feed_url)

Torna all'inizio