from flask import request, Flask
from oauth2 import AuthorizationController
from oauth2.store import LocalClientStore, LocalTokenStore
from oauth2.tokengenerator import Uuid4
from oauth2.web import SiteAdapter
from oauth2.grant import AuthorizationCodeGrant

class Request(object):
    """
    Simple wrapper around the Flask request object
    """
    @property
    def path(self):
        return request.path

    def get_param(self, name, default=None):
        return request.args.get(key=name, default=default)

    def post_param(self, name, default=None):
        return request.form.get(key=name, default=default)

class OAuth2(object):
    """
    Extend your Flask application to serve OAuth 2.0.
    """
    def __init__(self, access_token_store,
                 auth_token_store,
                 client_store,
                 site_adapter,
                 token_generator,
                 app=None,
                 authorize_path="/authorize",
                 token_path="/token"):
        self.access_token_store = access_token_store
        self.auth_token_store   = auth_token_store
        self.client_store       = client_store
        self.site_adapter       = site_adapter
        self.token_generator    = token_generator
        self.authorize_path      = authorize_path
        self.token_path          = token_path

        if app is not None:
            self.init_app(app)
        else:
            self.app = None

    def add_grant(self, grant):
        """
        Add a grant that your auth server shall support.
        """
        self.controller.add_grant(grant)

    def init_app(self, app):
        """
        Initializes view functions.
        """
        self.app = app

        self.controller = AuthorizationController(
            access_token_store=self.access_token_store,
            auth_token_store=self.auth_token_store,
            client_store=self.client_store,
            site_adapter=self.site_adapter,
            token_generator=self.token_generator)

        self.controller.authorize_path = self.authorize_path
        self.controller.token_path = self.token_path

        self.app.add_url_rule(self.authorize_path, "authorize", self._dispatch,
                              methods=["GET", "POST"])
        self.app.add_url_rule(self.token_path, "token", self._dispatch,
                              methods=["GET", "POST"])

    def _dispatch(self):
        assert self.controller is not None

        response = self.controller.dispatch(Request(), environ={})

        return response.body, response.status_code, response.headers

class MySiteAdapter(SiteAdapter):
    def authenticate(self, request, environ, scopes):
        # Authenticate every request
        return {}

def main():
    app = Flask(__name__)

    # Initialize storage
    client_store = LocalClientStore()
    client_store.add_client(client_id="abc", client_secret="xyz",
                            redirect_uris=["http://localhost:8081/callback"])

    token_store = LocalTokenStore()

    oauth_app = OAuth2(app=app, access_token_store=token_store,
                       auth_token_store=token_store, client_store=client_store,
                       site_adapter=MySiteAdapter(), token_generator=Uuid4())

    oauth_app.add_grant(AuthorizationCodeGrant())

    app.run(port=5000, debug=True)

    if __name__ == "__main__":
        main()

import tornado.web
import tornado.ioloop
from oauth2.store import LocalClientStore, LocalTokenStore
from oauth2 import AuthorizationController
from oauth2.tokengenerator import Uuid4
from oauth2.web import SiteAdapter
from oauth2.grant import ImplicitGrant, AuthorizationCodeGrant

class Request(object):
    """
    Wraps ``tornado.web.RequestHandler``.
    """
    def __init__(self, request_handler):
        self.request_handler = request_handler
        self.path = request_handler.request.path

    def get_param(self, name, default=None):
        return self._read_argument(name, default, source="GET")

    def post_param(self, name, default=None):
        return self._read_argument(name, default, source="POST")

    def _read_argument(self, name, default, source):
        if self.request_handler.request.method != source:
            return None
        try:
            return self.request_handler.get_argument(name)
        except tornado.web.MissingArgumentError:
            return default

class OAuth2Handler(tornado.web.RequestHandler):
    """
    Dispatches requests to an authorization controller
    """
    def initialize(self, controller):
        self.controller = controller

    def get(self):
        response = self._dispatch_request()

        self._map_response(response)

    def post(self):
        response = self._dispatch_request()

        self._map_response(response)

    def _dispatch_request(self):
        request = Request(request_handler=self)

        return self.controller.dispatch(request, environ={})

    def _map_response(self, response):
        for name, value in list(response.headers.items()):
            self.set_header(name, value)

        self.set_status(response.status_code)
        self.write(response.body)

class MySiteAdapter(SiteAdapter):
    def authenticate(self, request, environ, scopes):
        # Authenticate every request
        return {}

def main():
    # Initialize AuthorizationController as usual
    client_store = LocalClientStore()
    client_store.add_client(client_id="abc", client_secret="xyz",
                            redirect_uris=["http://localhost:8081/callback"])

    token_store = LocalTokenStore()

    auth_controller = AuthorizationController(
        access_token_store=token_store,
        auth_token_store=token_store,
        client_store=client_store,
        site_adapter=MySiteAdapter(),
        token_generator=Uuid4()
    )

    auth_controller.add_grant(AuthorizationCodeGrant())
    auth_controller.add_grant(ImplicitGrant())

    # Create your Tornado application and add the handler
    app = tornado.web.Application([
        (r'/authorize', OAuth2Handler, dict(controller=auth_controller))
    ])

    # Start the server
    app.listen(8888)
    tornado.ioloop.IOLoop.instance().start()

if __name__ == "__main__":
    main()