J'ai étudié comment utiliser l'API Graph lors de la création d'une application qui utilise les informations d'amis Facebook en Python, je vais donc le résumer. Il est destiné aux applications utilisant Flask.
Si vous redirigez vers https: //graph.facebook.com/oauth/authorize? Client_id = **** & redirect_uri = **** & scope = **** et que l'application n'est pas autorisée, l'application autorise La page s'affiche. Dans Flask, vous pouvez spécifier cette URL et faire return redirect (https: // ****).
| Paramètres | Réglages |
|---|---|
| client_id | ID d'application défini dans les développeurs Facebook |
| redirect_uri | URL à rediriger après authentification(Encodage URI requis) |
| scope | Autorisation de demander |
Si autorisé, il passera à la destination de redirection définie dans redirect_uri. Le code (code d'authentification) renvoyé en tant que paramètre à ce moment sera utilisé pour la prochaine acquisition de jeton d'accès. De plus, si une erreur se produit, la chaîne de caractères JSON avec le jeu ʻerror` est renvoyée comme indiqué ci-dessous.
error_sample
{
"error": {
"message": "redirect_uri isn't an absolute URI. Check RFC 3986.",
"type": "OAuthException",
"code": 191,
"fbtrace_id": "XXXXXXXXXXX"
}
}
Utilisez le code de vérification obtenu ci-dessus pour accéder à https: //graph.facebook.com/oauth/access_token? Client_id = **** & client_secret = **** & redirect_uri = **** & code = **** Accédez et obtenez un jeton d'accès.
| Paramètres | Réglages |
|---|---|
| client_id | ID d'application défini dans les développeurs Facebook |
| client_secret | Clé secrète d'application définie dans les développeurs Facebook |
| redirect_uri | URL à rediriger après authentification |
| code | Code d'authentification obtenu ci-dessus(Encodage URI requis) |
Les données acquises sont sous la forme de ʻaccess_token = **** & expires = **** , donc la valeur immédiatement après ʻaccess_token = est retirée. En Python, c'est une bonne idée d'utiliser quelque chose comme ʻurllib2.urlopen` pour obtenir le résultat. La méthode d'extraction est appropriée.
main.py
from werkzeug.urls import url_quote_plus
import urllib2
...
app_id = "xxxxxxxx"
app_secret = "xxxxxxxx"
url_redirect = url_quote_plus( "https://hogehoge.com" )
code = "xxxxxxxx"
url_token = ( "https://graph.facebook.com/oauth/access_token"
"?client_id={0}&client_secret={1}"
"&redirect_uri={2}&code={3}" )
try:
resp = urllib2.urlopen( url_token.format( app_id, app_secret, url_redirect, code ) )
data = resp.read().split('&')
access_token = data[0].strip('access_token=')
finally:
resp.close()
...
Vous avez maintenant obtenu un jeton d'accès.
Filtres Flask pour obtenir automatiquement un jeton d'accès lorsque vous visitez une page particulière. (Dans l'exemple ci-dessous, le traitement lorsqu'une erreur est renvoyée est omis.) Au fait, en Python, un tel filtre est-il un décorateur? Est-ce vrai? Je ne suis toujours pas sûr de ce domaine.
main.py
from werkzeug.urls import url_quote_plus
from functools import wraps
from flask import Flask, request, redirect, session
import urllib2
...
domain = "https://hogehoge.com"
app_id = "xxxxxxxx"
app_secret = "xxxxxxxx"
#Générer une URL pour obtenir un code d'autorisation--------------------------------------------------
def create_url_for_auth_code( path_orig ):
url_orig = url_quote_plus( domain + path_orig )
return ( "https://graph.facebook.com/oauth/authorize"
"?client_id={0}&redirect_uri={1}&scope={2}" )
#Obtenez un jeton d'accès--------------------------------------------------
def get_access_token( path_orig, code ):
url_orig = url_quote_plus( domain + path_orig )
url_token = ( "https://graph.facebook.com/oauth/access_token"
"?client_id={0}&client_secret={1}"
"&redirect_uri={2}&code={3}" )
try:
resp = urllib2.urlopen(url_token.format(app_id, app_secret, url_orig, code))
data = resp.read().split('&')
access_token = data[0].strip('access_token=')
finally:
resp.close()
return access_token
#Corps de filtre--------------------------------------------------
def oauth_filter(f):
@wraps(f)
def wrapper(*args, **kwargs):
#Si la session a un jeton d'accès, retournez-le tel quel
if session.has_key('access_token'):
return f(*args, **kwargs)
#Si la session n'a pas de jeton d'accès, obtenez-le par authentification oauth
code = request.args.get('code')
#Cas selon l'état des paramètres de la demande
if code is None:
#Obtenez le code si aucun code d'autorisation n'a été défini
return redirect( create_url_for_auth_code( request.path ) )
else:
#Obtenez un jeton d'accès si un code d'autorisation est défini
session['access_token'] = get_access_token( request.path, code )
return redirect( domain + request.path )
#Si les conditions ne sont pas remplies, quittez tel quel
return f(*args, **kwargs)
return wrapper
...
Appliquez le filtre ci-dessus. Tout ce que vous avez à faire est d'ajouter @ oauth_filter à la méthode qui spécifie chaque routage.
main.py
from flask import Flask, render_template, redirect, session
app = Flask(__name__)
...
#Ne s'applique pas à la première page
@app.route('/')
def index():
return render_template("top.html")
#S'applique à ma page
@app.route('/mypage')
@oauth_filter #Application! !!
def mypage():
return render_template("mypage.html")
#Supprimer le jeton d'accès de la session lors de la déconnexion
@app.route('/logout')
def logout():
if session.has_key( 'access_token' ):
del session['access_token']
return redirect( '/' )
...
Avec ce qui précède, cela devrait fonctionner pour le moment. Ces informations ont été créées sur la base de l'exemple PHP à l'aide de l'API Graph ci-dessous et de l'explication du décorateur de connexion Python.
Recommended Posts