在Flas中使用Google OAuth2

Question

有谁能给我举一个完整的例子，用OAuth2和Flask验证Google账户，而不是App Engine上的呢？

我试图让用户访问Google Calendar，然后使用该访问从日历中检索信息并进一步处理它。我还需要存储OAuth2令牌并在稍后刷新。

我已经看过Google的oauth2client库，并且可以开始检索授权代码，但是我有点迷路了。看看Google的OAuth 2.0 Playground，我知道我需要请求刷新令牌和访问令牌，但是库中提供的示例仅用于App Engine和Django。

我也尝试过使用Flask's OAuth module，其中包含对OAuth2的引用，但我也看不到任何方法可以在那里交换授权代码。

我可能会手工编写请求，但更希望使用或改编现有的python模块，使请求更容易、正确地处理可能的响应，甚至可能有助于存储令牌。

有这种事吗？

Answer 1

我已经搜索了很多关于使用不同库的信息，但从某种意义上讲，它们似乎都太过杀伤力（你可以在任何平台上使用它，但是你需要大量的代码）或者文档并没有解释我想要什么。长话短说-我从零开始写它，从而了解认证过程真正的谷歌API。并不像听起来那么难。基本上你需要遵循https://developers.google.com/accounts/docs/OAuth2WebServer准则，就这样。 为此，您还需要在https://code.google.com/apis/console/注册以生成凭据并注册链接。我使用了指向我的office IP的简单子域，因为它只允许域。

对于用户登录/管理和会话，我已经在flaskhttp://packages.python.org/Flask-Login/中使用了这个插件-将有一些基于它的代码。

所以第一件事-索引视图：

from flask import render_template
from flask.ext.login import current_user
from flask.views import MethodView

from myapp import app


class Index(MethodView):
    def get(self):
        # check if user is logged in
        if not current_user.is_authenticated():
            return app.login_manager.unauthorized()

        return render_template('index.html')

所以这个视图在我们拥有经过身份验证的用户之前不会打开。 谈论用户-用户模型：

from sqlalchemy.orm.exc import NoResultFound
from sqlalchemy import Column, Integer, DateTime, Boolean, String

from flask.ext.login import UserMixin
from myapp.metadata import Session, Base


class User(Base):
    __tablename__ = 'myapp_users'

    id = Column(Integer, primary_key=True)
    email = Column(String(80), unique=True, nullable=False)
    username = Column(String(80), unique=True, nullable=False)

    def __init__(self, email, username):
        self.email = email
        self.username = username

    def __repr__(self):
        return "<User('%d', '%s', '%s')>" \
                % (self.id, self.username, self.email)

    @classmethod
    def get_or_create(cls, data):
        """
        data contains:
            {u'family_name': u'Surname',
            u'name': u'Name Surname',
            u'picture': u'https://link.to.photo',
            u'locale': u'en',
            u'gender': u'male',
            u'email': u'propper@email.com',
            u'birthday': u'0000-08-17',
            u'link': u'https://plus.google.com/id',
            u'given_name': u'Name',
            u'id': u'Google ID',
            u'verified_email': True}
        """
        try:
            #.one() ensures that there would be just one user with that email.
            # Although database should prevent that from happening -
            # lets make it buletproof
            user = Session.query(cls).filter_by(email=data['email']).one()
        except NoResultFound:
            user = cls(
                    email=data['email'],
                    username=data['given_name'],
                )
            Session.add(user)
            Session.commit()
        return user

    def is_active(self):
        return True

    def is_authenticated(self):
        """
        Returns `True`. User is always authenticated. Herp Derp.
        """
        return True

    def is_anonymous(self):
        """
        Returns `False`. There are no Anonymous here.
        """
        return False

    def get_id(self):
        """
        Assuming that the user object has an `id` attribute, this will take
        that and convert it to `unicode`.
        """
        try:
            return unicode(self.id)
        except AttributeError:
            raise NotImplementedError("No `id` attribute - override get_id")

    def __eq__(self, other):
        """
        Checks the equality of two `UserMixin` objects using `get_id`.
        """
        if isinstance(other, UserMixin):
            return self.get_id() == other.get_id()
        return NotImplemented

    def __ne__(self, other):
        """
        Checks the inequality of two `UserMixin` objects using `get_id`.
        """
        equal = self.__eq__(other)
        if equal is NotImplemented:
            return NotImplemented
        return not equal

UserMixin可能有问题，但我将处理后者。您的用户模型看起来会有所不同，只需使其与flask登录兼容即可。

所以剩下的就是自我认证。我为flask-login设置的登录视图是'login'。Login视图呈现带有登录按钮的html，该按钮指向google-google重定向到Auth视图。它应该可以只是重定向用户到谷歌的情况下，它的网站只有登录用户。

import logging
import urllib
import urllib2
import json

from flask import render_template, url_for, request, redirect
from flask.views import MethodView
from flask.ext.login import login_user

from myapp import settings
from myapp.models import User


logger = logging.getLogger(__name__)


class Login(BaseViewMixin):
    def get(self):
        logger.debug('GET: %s' % request.args)
        params = {
            'response_type': 'code',
            'client_id': settings.GOOGLE_API_CLIENT_ID,
            'redirect_uri': url_for('auth', _external=True),
            'scope': settings.GOOGLE_API_SCOPE,
            'state': request.args.get('next'),
        }
        logger.debug('Login Params: %s' % params)
        url = settings.GOOGLE_OAUTH2_URL + 'auth?' + urllib.urlencode(params)

        context = {'login_url': url}
        return render_template('login.html', **context)


class Auth(MethodView):
    def _get_token(self):
        params = {
            'code': request.args.get('code'),
            'client_id': settings.GOOGLE_API_CLIENT_ID,
            'client_secret': settings.GOOGLE_API_CLIENT_SECRET,
            'redirect_uri': url_for('auth', _external=True),
            'grant_type': 'authorization_code',
        }
        payload = urllib.urlencode(params)
        url = settings.GOOGLE_OAUTH2_URL + 'token'

        req = urllib2.Request(url, payload)  # must be POST

        return json.loads(urllib2.urlopen(req).read())

    def _get_data(self, response):
        params = {
            'access_token': response['access_token'],
        }
        payload = urllib.urlencode(params)
        url = settings.GOOGLE_API_URL + 'userinfo?' + payload

        req = urllib2.Request(url)  # must be GET

        return json.loads(urllib2.urlopen(req).read())

    def get(self):
        logger.debug('GET: %s' % request.args)

        response = self._get_token()
        logger.debug('Google Response: %s' % response)

        data = self._get_data(response)
        logger.debug('Google Data: %s' % data)

        user = User.get_or_create(data)
        login_user(user)
        logger.debug('User Login: %s' % user)
        return redirect(request.args.get('state') or url_for('index'))

所以所有的东西都被分成两部分-第一部分是在_get_token中获取google令牌。其他用于在_get_data中使用它和检索基本用户数据。

我的设置文件包含：

GOOGLE_API_CLIENT_ID = 'myid.apps.googleusercontent.com'
GOOGLE_API_CLIENT_SECRET = 'my secret code'
GOOGLE_API_SCOPE = 'https://www.googleapis.com/auth/userinfo.profile https://www.googleapis.com/auth/userinfo.email'
GOOGLE_OAUTH2_URL = 'https://accounts.google.com/o/oauth2/'
GOOGLE_API_URL = 'https://www.googleapis.com/oauth2/v1/'

请记住，视图必须有附加到应用程序的url路径，所以我使用了这个urls.py文件，这样我可以更轻松地跟踪我的视图，并将更少的内容导入flask应用程序创建文件：

from myapp import app
from myapp.views.auth import Login, Auth
from myapp.views.index import Index


urls = {
    '/login/': Login.as_view('login'),
    '/auth/': Auth.as_view('auth'),
    '/': Index.as_view('index'),
}

for url, view in urls.iteritems():
    app.add_url_rule(url, view_func=view)

所有这些加在一起使得谷歌授权工作在烧瓶。如果你复制粘贴它-它可能需要一些与flask登录文档和SQLAlchemy映射的修补，但想法是存在的。

Answer 2

试试Authomatic（我是那个项目的维护者）。它使用非常简单，可以与任何Python框架一起工作，并且支持16oauth 2.0，10oauth 1.0a提供程序和OpenID。

下面是一个简单的示例，介绍如何使用Google对用户进行身份验证，并获取他/她的YouTube视频列表：

# main.py

from flask import Flask, request, make_response, render_template
from authomatic.adapters import WerkzeugAdapter
from authomatic import Authomatic
from authomatic.providers import oauth2


CONFIG = {
    'google': {
        'class_': oauth2.Google,
        'consumer_key': '########################',
        'consumer_secret': '########################',
        'scope': oauth2.Google.user_info_scope + ['https://gdata.youtube.com'],
    },
}

app = Flask(__name__)
authomatic = Authomatic(CONFIG, 'random secret string for session signing')


@app.route('/login/<provider_name>/', methods=['GET', 'POST'])
def login(provider_name):
    response = make_response()

    # Authenticate the user
    result = authomatic.login(WerkzeugAdapter(request, response), provider_name)

    if result:
        videos = []
        if result.user:
            # Get user info
            result.user.update()

            # Talk to Google YouTube API
            if result.user.credentials:
                response = result.provider.access('https://gdata.youtube.com/'
                    'feeds/api/users/default/playlists?alt=json')
                if response.status == 200:
                    videos = response.data.get('feed', {}).get('entry', [])

        return render_template(user_name=result.user.name,
                               user_email=result.user.email,
                               user_id=result.user.id,
                               youtube_videos=videos)
    return response


if __name__ == '__main__':
    app.run(debug=True)

还有一个非常简单的Flask tutorial，它展示了如何通过Facebook和Twitter对用户进行身份验证，并与他们的api对话以读取用户的新闻提要。

Answer 3

另一个答案提到Flask-Rauth，但没有详细说明如何使用它。有一些Google特有的问题，但我最终实现了它，它工作得很好。我把它与Flask登录集成起来，这样我就可以用像@login_required这样有用的糖来装饰我的视图。

我希望能够支持多个OAuth2提供者，因此部分代码是通用的，并且基于Miguel Grinberg关于用脸谱网和Twitter支持OAuth2的优秀文章here。

首先，将来自Google的特定Google身份验证信息添加到应用程序的配置中：

GOOGLE_LOGIN_CLIENT_ID = "<your-id-ending-with>.apps.googleusercontent.com"
GOOGLE_LOGIN_CLIENT_SECRET = "<your-secret>"

OAUTH_CREDENTIALS={
        'google': {
            'id': GOOGLE_LOGIN_CLIENT_ID,
            'secret': GOOGLE_LOGIN_CLIENT_SECRET
        }
}

当您创建应用程序时（在我的例子中，模块的__init__.py）：

app = Flask(__name__)
app.config.from_object('config')

在应用程序模块中，创建auth.py：

from flask import url_for, current_app, redirect, request
from rauth import OAuth2Service

import json, urllib2

class OAuthSignIn(object):
    providers = None

    def __init__(self, provider_name):
        self.provider_name = provider_name
        credentials = current_app.config['OAUTH_CREDENTIALS'][provider_name]
        self.consumer_id = credentials['id']
        self.consumer_secret = credentials['secret']

    def authorize(self):
        pass

    def callback(self):
        pass

    def get_callback_url(self):
        return url_for('oauth_callback', provider=self.provider_name,
                        _external=True)

    @classmethod
    def get_provider(self, provider_name):
        if self.providers is None:
            self.providers={}
            for provider_class in self.__subclasses__():
                provider = provider_class()
                self.providers[provider.provider_name] = provider
        return self.providers[provider_name]

class GoogleSignIn(OAuthSignIn):
    def __init__(self):
        super(GoogleSignIn, self).__init__('google')
        googleinfo = urllib2.urlopen('https://accounts.google.com/.well-known/openid-configuration')
        google_params = json.load(googleinfo)
        self.service = OAuth2Service(
                name='google',
                client_id=self.consumer_id,
                client_secret=self.consumer_secret,
                authorize_url=google_params.get('authorization_endpoint'),
                base_url=google_params.get('userinfo_endpoint'),
                access_token_url=google_params.get('token_endpoint')
        )

    def authorize(self):
        return redirect(self.service.get_authorize_url(
            scope='email',
            response_type='code',
            redirect_uri=self.get_callback_url())
            )

    def callback(self):
        if 'code' not in request.args:
            return None, None, None
        oauth_session = self.service.get_auth_session(
                data={'code': request.args['code'],
                      'grant_type': 'authorization_code',
                      'redirect_uri': self.get_callback_url()
                     },
                decoder = json.loads
        )
        me = oauth_session.get('').json()
        return (me['name'],
                me['email'])

这将创建一个可以子类化的泛型OAuthSignIn类。Google子类从Google发布的信息列表中提取信息（JSON格式here）。这是随时可能更改的信息，因此这种方法将确保它始终是最新的。其中一个限制是，如果在初始化Flask应用程序（导入的模块）时服务器上没有可用的Internet连接，则无法正确实例化该应用程序。这几乎不应该是一个问题，但是在配置数据库中存储最后一个已知的值来覆盖这种可能性是一个好主意。

最后，类在callback()函数中返回name, email的元组。实际上，Google会返回更多信息，包括Google+个人资料（如果有的话）。检查oauth_session.get('').json()返回的字典以查看全部内容。 如果在authorize()函数中扩展作用域（对于我的应用程序，email就足够了），则可以通过Google API访问更多信息。

接下来，编写视图将其绑定在一起：

from flask.ext.login import login_user, logout_user, current_user, login_required

@app.route('/authorize/<provider>')
def oauth_authorize(provider):
    # Flask-Login function
    if not current_user.is_anonymous():
        return redirect(url_for('index'))
    oauth = OAuthSignIn.get_provider(provider)
    return oauth.authorize()

@app.route('/callback/<provider>')
def oauth_callback(provider):
    if not current_user.is_anonymous():
        return redirect(url_for('index'))
    oauth = OAuthSignIn.get_provider(provider)
    username, email = oauth.callback()
    if email is None:
        # I need a valid email address for my user identification
        flash('Authentication failed.')
        return redirect(url_for('index'))
    # Look if the user already exists
    user=User.query.filter_by(email=email).first()
    if not user:
        # Create the user. Try and use their name returned by Google,
        # but if it is not set, split the email address at the @.
        nickname = username
        if nickname is None or nickname == "":
            nickname = email.split('@')[0]

        # We can do more work here to ensure a unique nickname, if you 
        # require that.
        user=User(nickname=nickname, email=email)
        db.session.add(user)
        db.session.commit()
    # Log in the user, by default remembering them for their next visit
    # unless they log out.
    login_user(user, remember=True)
    return redirect(url_for('index'))

最后，我的/login视图和模板来实现这一切：

@app.route('/login', methods=['GET', 'POST'])
def login():
    if g.user is not None and g.user.is_authenticated():
        return redirect(url_for('index'))
    return render_template('login.html',
                           title='Sign In')

登录.html：

{% extends "base.html" %}

{% block content %}

    <div id="sign-in">
        <h1>Sign In</h1>
        <p>
        <a href={{ url_for('oauth_authorize', provider='google') }}><img src="{{ url_for('static', filename='img/sign-in-with-google.png') }}" /></a>
    </div>
{% endblock %}

确保正确的回呼地址在Google注册，用户只需点击登录页面上的“登录Google”，它就会注册并登录。