コード例 #1
0
def enable_github_oauth(GITHUB_ENABLE):
    if not GITHUB_ENABLE:
        return None, None
    from flask_oauthlib.client import OAuth
    oauth = OAuth(app)
    github = oauth.remote_app(
        'github',
        consumer_key=app.config['GITHUB_OAUTH_KEY'],
        consumer_secret=app.config['GITHUB_OAUTH_SECRET'],
        request_token_params={'scope': app.config['GITHUB_OAUTH_SCOPE']},
        base_url=app.config['GITHUB_OAUTH_URL'],
        request_token_url=None,
        access_token_method='POST',
        access_token_url=app.config['GITHUB_OAUTH_TOKEN'],
        authorize_url=app.config['GITHUB_OAUTH_AUTHORIZE']
    )

    @app.route('/user/authorized')
    def authorized():
        session['github_oauthredir'] = url_for('.authorized', _external=True)
        resp = github.authorized_response()
        if resp is None:
            return 'Access denied: reason=%s error=%s' % (
                request.args['error'],
                request.args['error_description']
            )
        session['github_token'] = (resp['access_token'], '')
        return redirect(url_for('.login'))

    @github.tokengetter
    def get_github_oauth_token():
        return session.get('github_token')

    return oauth, github
コード例 #2
0
ファイル: api.py プロジェクト: the-gigi/over-achiever
def create_app():
    app = Flask(__name__)
    app.config.from_object('over_achiever.config')
    db = SQLAlchemy(app, metadata=models.metadata)
    db.create_all()
    resources.db = app.db = db

    oauth = OAuth(app)
    github = oauth.remote_app(
        'github',
        consumer_key='507e57ab372adeb8051b',
        consumer_secret='08a7dbaa06ac16daab00fac53724ee742c8081c5',
        request_token_params={'scope': 'user:email'},
        base_url='https://api.github.com/',
        request_token_url=None,
        access_token_method='POST',
        access_token_url='https://github.com/login/oauth/access_token',
        authorize_url='https://github.com/login/oauth/authorize'
    )

    # set the token getter for the auth client
    github._tokengetter = lambda: session.get('github_token')
    resources.github = app.github = github

    api = Api(app)
    resource_map = (
        (User, '/v1.0/users'),
        (Goal, '/v1.0/goals'),
    )

    for resource, route in resource_map:
        api.add_resource(resource, route)

    return app
コード例 #3
0
ファイル: controllers.py プロジェクト: jamilatta/opac
def get_collection_tweets():

    tweets = []
    oauth = OAuth(current_app)
    twitter = oauth.remote_app(
        'twitter',
        base_url='https://api.twitter.com/1.1/',
        request_token_url='https://api.twitter.com/oauth/request_token',
        access_token_url='https://api.twitter.com/oauth/access_token',
        authorize_url='https://api.twitter.com/oauth/authenticate',
        consumer_key=current_app.config['TWITTER_CONSUMER_KEY'],
        consumer_secret=current_app.config['TWITTER_CONSUMER_SECRET']
    )

    @twitter.tokengetter
    def get_twitter_token():
        return (
            current_app.config['TWITTER_ACCESS_TOKEN'],
            current_app.config['TWITTER_ACCESS_TOKEN_SECRET']
        )

    response = twitter.request('statuses/user_timeline.json', data={
        'screen_name': current_app.config['TWITTER_SCREEN_NAME'],
        'count': current_app.config['TWITTER_LIMIT'],
    })

    if response.status == 200:
        tweets = response.data

    return tweets
コード例 #4
0
    def test_lazy_load(self):
        oauth = OAuth()
        twitter = oauth.remote_app(
            'twitter',
            base_url='https://api.twitter.com/1/',
            app_key='twitter'
        )
        assert twitter.base_url == 'https://api.twitter.com/1/'

        app = Flask(__name__)
        app.config.update({
            'twitter': dict(
                consumer_key='twitter key',
                consumer_secret='twitter secret',
                request_token_url='request url',
                access_token_url='token url',
                authorize_url='auth url',
            )
        })
        oauth.init_app(app)
        assert twitter.consumer_key == 'twitter key'
        assert twitter.consumer_secret == 'twitter secret'
        assert twitter.request_token_url == 'request url'
        assert twitter.access_token_url == 'token url'
        assert twitter.authorize_url == 'auth url'
        assert twitter.content_type is None
def make_twitter(flask_app):
    oauth = OAuth(flask_app)
    return oauth.remote_app('twitter',
            base_url='https://api.twitter.com/1.1/',
            request_token_url='https://api.twitter.com/oauth/request_token',
            access_token_url='https://api.twitter.com/oauth/access_token',
            authorize_url='https://api.twitter.com/oauth/authenticate',
            consumer_key=os.getenv('TWITTER_CONSUMER_KEY'),
            consumer_secret=os.getenv('TWITTER_CONSUMER_SECRET'))
コード例 #6
0
ファイル: login_oauth.py プロジェクト: AAIDev/SpaceDock
def get_oauth_provider(provider):
    oauth = OAuth(current_app)
    if provider == 'github':
        github = oauth.remote_app(
            'github',
            consumer_key=_cfg('gh-oauth-id'),
            consumer_secret=_cfg('gh-oauth-secret'),
            request_token_params={'scope': 'user:email'},
            base_url='https://api.github.com/',
            request_token_url=None,
            access_token_method='POST',
            access_token_url='https://github.com/login/oauth/access_token',
            authorize_url='https://github.com/login/oauth/authorize'
        )

        @github.tokengetter
        def get_github_oauth_token():
            return session.get('github_token')

        return github

    if provider == 'google':
        google = oauth.remote_app(
            'google',
            consumer_key=_cfg('google-oauth-id'),
            consumer_secret=_cfg('google-oauth-secret'),
            request_token_params={'scope': 'email'},
            base_url='https://www.googleapis.com/oauth2/v1/',
            request_token_url=None,
            access_token_method='POST',
            access_token_url='https://accounts.google.com/o/oauth2/token',
            authorize_url='https://accounts.google.com/o/oauth2/auth',
        )

        @google.tokengetter
        def get_google_oauth_token():
            return session.get('google_token')

        return google

    raise Exception('This OAuth provider was not implemented: ' + provider)
def make_lepture(app, ck, cs):
    oauth = OAuth(app)
    return oauth.remote_app('lepture',
            consumer_key=ck,
            consumer_secret=cs,
            request_token_params={
                'realm': 'email'},
            base_url='http://127.0.0.1:5000/api/',
            request_token_url='http://127.0.0.1:5000/oauth/request_token',
            access_token_method='GET',
            access_token_url='http://127.0.0.1:5000/oauth/access_token',
            authorize_url='http://127.0.0.1:5000/oauth/authorize')
コード例 #8
0
ファイル: model.py プロジェクト: hammygoonan/FlaskTemplate
 def __init__(self):
     super().__init__('twitter')
     oauth = OAuth()
     self.service = oauth.remote_app(
         'twitter',
         base_url='https://api.twitter.com/1/',
         request_token_url='https://api.twitter.com/oauth/request_token',
         access_token_url='https://api.twitter.com/oauth/access_token',
         authorize_url='https://api.twitter.com/oauth/authenticate',
         consumer_key=app.config['TWITTER_CUSTOMER_KEY'],
         consumer_secret=app.config['TWITTER_CUSTOMER_SECRET']
     )
     self.service.tokengetter = TwitterSignIn.get_token
コード例 #9
0
def create_client(app):
    oauth = OAuth(app)

    dev = oauth.remote_app(
        'dev',
        consumer_key='dev',
        consumer_secret='dev',
        request_token_params={'scope': 'email'},
        base_url='http://127.0.0.1:5000/api/',
        request_token_url=None,
        access_token_method='GET',
        access_token_url='http://127.0.0.1:5000/oauth/access_token',
        authorize_url='http://127.0.0.1:5000/oauth/authorize'
    )

    @app.route('/')
    def index():
        if 'dev_token' in session:
            ret = dev.get('email')
            return jsonify(ret.data)
        return redirect(url_for('login'))

    @app.route('/login')
    def login():
        return dev.authorize(callback=url_for('authorized', _external=True))

    @app.route('/logout')
    def logout():
        session.pop('dev_token', None)
        return redirect(url_for('index'))

    @app.route('/authorized')
    @dev.authorized_handler
    def authorized(resp):
        if resp is None:
            return 'Access denied: error=%s' % (
                request.args['error']
            )
        session['dev_token'] = (resp['access_token'], '')
        return jsonify(resp)

    @app.route('/address')
    def address():
        ret = dev.get('address')
        return ret.raw_data

    @dev.tokengetter
    def get_oauth_token():
        return session.get('dev_token')

    return app
コード例 #10
0
ファイル: oauth.py プロジェクト: richburdon/dark-zero
class OAuthRegistry(object):

    def __init__(self):
        self.oauth = OAuth(self.app)

        # Map of remote apps indexed by service ID.
        self.remote = dict()

        # Create remote apps.
        for config_id in self.configs:
            print 'Registered OAuth: {0}'.format(config_id)
            self.app.config[config_id] = self.configs[config_id]
            remote = self.oauth.remote_app(config_id, app_key=config_id)
            self.remote[config_id] = remote
コード例 #11
0
def install_github_oauth(app):
    oauth = OAuth(app)
    github_auth = oauth.remote_app(
        'github',
        consumer_key=app.config['GITHUB_CLIENT_ID'],
        consumer_secret=app.config['GITHUB_CLIENT_SECRET'],
        request_token_params={'scope': 'repo,user'},
        base_url='https://api.github.com/',
        request_token_url=None,
        access_token_method='POST',
        access_token_url='https://github.com/login/oauth/access_token',
        authorize_url='https://github.com/login/oauth/authorize'
    )

    @app.route('/login')
    def login():
        return github_auth.authorize(callback=url_for('authorized', _external=True, next=request.args.get('next') or request.referrer or None))


    @app.route('/logout')
    def logout():
        session.pop('token', None)
        return redirect(url_for('index'))


    @app.route('/oauth_callback')
    @github_auth.authorized_handler
    def authorized(resp):
        next_url = request.args.get('next') or url_for('index')
        if resp is None:
            return 'Access denied: reason=%s error=%s' % (
                request.args['error_reason'],
                request.args['error_description']
            )
        session['token'] = resp['access_token']
        user_info = github.get_current_user_info(session['token'])
        if not user_info:
            return "Unable to get user info."
        session['login'] = user_info['login']
        return redirect(next_url)


    @github_auth.tokengetter
    def get_github_oauth_token():
        token = session.get('token')
        if token:
            return (token, '')
        else:
            return token
コード例 #12
0
ファイル: auth.py プロジェクト: eyalr/frippery
def initialize(app):
    app.secret_key = 'development'
    oauth = OAuth(app)

    host_eb_apis = {
        'tourney': oauth.remote_app(
            'eventbrite-tourney',
            consumer_key=settings.tourney_consumer_key,
            consumer_secret=settings.tourney_secret_key,
            request_token_params={
                'state': lambda: security.gen_salt(10)
            },
            base_url='https://www.eventbriteapi.com/v3/',
            request_token_url=None,
            access_token_method='POST',
            access_token_url='https://www.eventbrite.com/oauth/token',
            authorize_url='https://www.eventbrite.com/oauth/authorize',
        ),
        'secret-santa': oauth.remote_app(
            'eventbrite-ss',
            consumer_key=settings.secret_santa_consumer_key,
            consumer_secret=settings.secret_santa_secret_key,
            request_token_params={
                'state': lambda: security.gen_salt(10)
            },
            base_url='https://www.eventbriteapi.com/v3/',
            request_token_url=None,
            access_token_method='POST',
            access_token_url='https://www.eventbrite.com/oauth/token',
            authorize_url='https://www.eventbrite.com/oauth/authorize',
        ),
    }
    for _api in host_eb_apis.values():
        _api.tokengetter(lambda *args: session.get('eventbrite_token'))

    return host_eb_apis
コード例 #13
0
ファイル: client.py プロジェクト: Charlesdong/flask-oauthlib
def create_oauth(app):
    oauth = OAuth(app)

    remote = oauth.remote_app(
        'dev',
        consumer_key='dev',
        consumer_secret='dev',
        request_token_params={'realm': 'email'},
        base_url='http://127.0.0.1:5000/api/',
        request_token_url='http://127.0.0.1:5000/oauth/request_token',
        access_token_method='GET',
        access_token_url='http://127.0.0.1:5000/oauth/access_token',
        authorize_url='http://127.0.0.1:5000/oauth/authorize'
    )
    return remote
コード例 #14
0
ファイル: test_oauth1.py プロジェクト: devunt/flask-oauthlib
    def create_client(self, app):
        oauth = OAuth(app)

        remote = oauth.remote_app(
            'dev',
            consumer_key='noclient',
            consumer_secret='dev',
            request_token_params={'realm': 'email'},
            base_url='http://localhost/api/',
            request_token_url='http://localhost/oauth/request_token',
            access_token_method='GET',
            access_token_url='http://localhost/oauth/access_token',
            authorize_url='http://localhost/oauth/authorize'
        )
        return create_client(app, remote)
コード例 #15
0
ファイル: api.py プロジェクト: jameslafa/500px-fav-downloader
    def __init__(self, consumer_key, consumer_secret):
        oauth = OAuth()
        self.api = oauth.remote_app('500px-fav-downloader',
                                    base_url='https://api.500px.com/v1/',
                                    request_token_url='https://api.500px.com/v1/oauth/request_token',
                                    access_token_url='https://api.500px.com/v1/oauth/access_token',
                                    authorize_url='https://api.500px.com/v1/oauth/authorize',
                                    consumer_key=consumer_key,
                                    consumer_secret=consumer_secret
                                    )

        self.oauth_token = None
        self.oauth_token_secret = None

        # Register the function to get the tokens
        self.api.tokengetter(self.get_oauth_token)
コード例 #16
0
ファイル: test_client.py プロジェクト: StetHD/flask-oauthlib
def test_app():
    app = Flask(__name__)
    oauth = OAuth(app)
    remote = oauth.remote_app(
        'dev',
        consumer_key='dev',
        consumer_secret='dev',
        request_token_params={'scope': 'email'},
        base_url='http://127.0.0.1:5000/api/',
        request_token_url=None,
        access_token_method='POST',
        access_token_url='http://127.0.0.1:5000/oauth/token',
        authorize_url='http://127.0.0.1:5000/oauth/authorize'
    )
    client = app.extensions['oauthlib.client']
    assert client.dev.name == 'dev'
コード例 #17
0
ファイル: oauth.py プロジェクト: indictools/scan2text
 def __init__(self, client_id, client_secret):
   super(GoogleSignIn, self).__init__(provider_name="google")
   oauth = OAuth()
   self.service = oauth.remote_app(
     'google',
     consumer_key=client_id,
     consumer_secret=client_secret,
     request_token_params={
       'scope': 'email'
     },
     base_url='https://www.googleapis.com/oauth2/v1/',
     request_token_url=None,
     access_token_method='POST',
     access_token_url='https://accounts.google.com/o/oauth2/token',
     authorize_url='https://accounts.google.com/o/oauth2/auth',
   )
   self.service.tokengetter(GoogleSignIn._get_token)
コード例 #18
0
ファイル: model.py プロジェクト: hammygoonan/FlaskTemplate
 def __init__(self):
     super().__init__('google')
     oauth = OAuth()
     self.service = oauth.remote_app(
         'google',
         consumer_key=app.config['GOOGLE_CLIENT_ID'],
         consumer_secret=app.config['GOOGLE_CLIENT_SECRET'],
         request_token_params={
             'scope': 'email'
         },
         base_url='https://www.googleapis.com/oauth2/v1/',
         request_token_url=None,
         access_token_method='POST',
         access_token_url='https://accounts.google.com/o/oauth2/token',
         authorize_url='https://accounts.google.com/o/oauth2/auth',
     )
     self.service.tokengetter(GoogleSignIn.get_token)
コード例 #19
0
ファイル: auth.py プロジェクト: Cal-CS-61A-Staff/ok
def record_params(setup_state):
    """ Load used app configs into local config on registration from
    server/__init__.py """
    global provider_name
    global provider_auth
    global oauth
    oauth = OAuth()
    app = setup_state.app
    provider_name = app.config.get('OAUTH_PROVIDER', GOOGLE)
    provider_auth = oauth.remote_app(
        provider_name, 
        app_key=provider_name
    )
    
    oauth.init_app(app)
    #instead of decorator set the fn pointer to the func here:
    provider_auth._tokengetter = provider_token
コード例 #20
0
    def test_lazy_load_with_plain_text_config(self):
        oauth = OAuth()
        twitter = oauth.remote_app('twitter', app_key='TWITTER')

        app = Flask(__name__)
        app.config['TWITTER_CONSUMER_KEY'] = 'twitter key'
        app.config['TWITTER_CONSUMER_SECRET'] = 'twitter secret'
        app.config['TWITTER_REQUEST_TOKEN_URL'] = 'request url'
        app.config['TWITTER_ACCESS_TOKEN_URL'] = 'token url'
        app.config['TWITTER_AUTHORIZE_URL'] = 'auth url'

        oauth.init_app(app)

        assert twitter.consumer_key == 'twitter key'
        assert twitter.consumer_secret == 'twitter secret'
        assert twitter.request_token_url == 'request url'
        assert twitter.access_token_url == 'token url'
        assert twitter.authorize_url == 'auth url'
コード例 #21
0
 def __init__(self,app,oauth_name=None,oauth_key=None,oauth_secret=None,oauth_scope=None,oauth_access_token_url=None,
              oauth_authorize_url=None,oauth_request_token_url=None,oauth_base_api_url=None,oauth_callback_url=None,
              *args,**kwargs):
     super(NemoOauthPlugin, self).__init__(*args,**kwargs)
     oauth = OAuth(app)
     self.authobj = oauth.remote_app(
         oauth_name,
         consumer_key=oauth_key,
         consumer_secret=oauth_secret,
         request_token_params={'scope':oauth_scope},
         base_url=oauth_base_api_url,
         request_token_url=oauth_request_token_url,
         access_token_method='POST',
         access_token_url=oauth_access_token_url,
         authorize_url=oauth_authorize_url
     )
     self.authobj.tokengetter(self.oauth_token)
     self.authcallback = oauth_callback_url
コード例 #22
0
ファイル: app_init.py プロジェクト: JohnCEarls/tcdiracweb
def get_google( app ):
    oauth = OAuth(app)
    app.logger.debug( app.config.keys() )
    google = oauth.remote_app(
        'google',
        consumer_key=app.config.get('GOOGLE_ID'),
        consumer_secret=app.config.get('GOOGLE_SECRET'),
        request_token_params={
            'scope': ['profile', 'https://www.googleapis.com/auth/userinfo.email'],
            'approval_prompt' : 'force',
            'access_type':'offline'
        },
        base_url='https://www.googleapis.com/oauth2/v1/',
        request_token_url=None,
        access_token_method='POST',
        access_token_url='https://accounts.google.com/o/oauth2/token',
        authorize_url='https://accounts.google.com/o/oauth2/auth',
    )
    return google
コード例 #23
0
ファイル: google.py プロジェクト: rjw57/richwareham.com
def create_oauth(app):
    oauth = OAuth(app)
    google = oauth.remote_app('google',
        consumer_key=GOOGLE_ID,
        consumer_secret=GOOGLE_SECRET,
        request_token_params={
            'scope': 'https://www.googleapis.com/auth/userinfo.email'
        },
        base_url='https://www.googleapis.com/oauth2/v1/',
        request_token_url=None,
        access_token_method='POST',
        access_token_url='https://accounts.google.com/o/oauth2/token',
        authorize_url='https://accounts.google.com/o/oauth2/auth',
    )

    @google.tokengetter
    def get_google_oauth_token():
        return session.get('google_token')

    return google
コード例 #24
0
from flask import Flask, url_for, session, request, jsonify
from flask_oauthlib.client import OAuth

CLIENT_ID = 'ybazvHasortLpoSvnbeoLQssh311isEfizKsCAs3'
CLIENT_SECRET = 'kxrgkC07lp9XGoAq4l9JNJrDbuZ9CkfYdzwKvtxQB1JfMTo30V'

app = Flask(__name__)
app.debug = True
app.secret_key = 'secret'
oauth = OAuth(app)

remote = oauth.remote_app(
    'remote',
    consumer_key=CLIENT_ID,
    consumer_secret=CLIENT_SECRET,
    request_token_params={'scope': 'email'},
    base_url='http://192.168.2.1:8080/api/',
    request_token_url=None,
    access_token_url='http://192.168.2.1:8080/oauth/token',
    authorize_url='http://192.168.2.1:8080/oauth/authorize')


@app.route('/')
def index():
    if 'remote_oauth' in session:
        resp = remote.get('me')
        return jsonify(resp.data)
    next_url = request.args.get('next') or request.referrer or None
    return remote.authorize(
        callback=url_for('authorized', next=next_url, _external=True))
コード例 #25
0
ファイル: login.py プロジェクト: amal66/Kawm
GOOGLE_DISCOVERY_URL = (
    "https://accounts.google.com/.well-known/openid-configuration")
facebook_credentials = app.config['OAUTH_CREDENTIALS']['facebook']
FACEBOOK_APP_ID = facebook_credentials['id']
FACEBOOK_APP_SECRET = facebook_credentials['secret']
SECRET_KEY = app.secret_key

# OAuth 2 client setup
google_client = WebApplicationClient(GOOGLE_CLIENT_ID)

oauth = OAuth()
facebook = oauth.remote_app(
    'facebook',
    base_url='https://graph.facebook.com/',
    request_token_url=None,
    access_token_url='/oauth/access_token',
    authorize_url='https://www.facebook.com/dialog/oauth',
    consumer_key=FACEBOOK_APP_ID,
    consumer_secret=FACEBOOK_APP_SECRET,
    request_token_params={'scope': 'email'})


# Helper method to get user URL
def get_google_provider_cfg():
    return requests.get(GOOGLE_DISCOVERY_URL).json()


login_template = Blueprint('login',
                           __name__,
                           template_folder='../templates',
                           static_folder='../static')
コード例 #26
0
from angular_flask import app

from flask_sqlalchemy import SQLAlchemy
from flask_restless import APIManager
from flask_oauthlib.client import OAuth

db = SQLAlchemy(app)
oauth = OAuth()

etsy = oauth.remote_app(
    'etsy',
    base_url='https://openapi.etsy.com/v2',
    request_token_url=
    'https://openapi.etsy.com/v2/oauth/request_token?scope=profile_r%20email_r%20listings_r%20transactions_r%20transactions_w%20shops_rw%20',
    access_token_url='https://openapi.etsy.com/v2/oauth/access_token',
    authorize_url='https://etsy.com/oauth/signin',
    consumer_key='fvfa290fd1oj7mz3q9sz8de3',
    consumer_secret='mrxd5mxylm')

t = {}
t['request_token_url'] = 'https://api.twitter.com/oauth/request_token'
t['access_token_url'] = 'https://api.twitter.com/oauth/access_token'
t['authorize_url'] = 'https://api.twitter.com/oauth/authenticate'
t['consumer_key'] = 'r5dp81cC7nk1Vkk6FwsBJICHf'
t['consumer_secret'] = '58Rf705PdE8SuWolk5DxAptS6kHyfASB1TptLf5yZevHsGgaLu'

twittero = oauth.remote_app(
    base_url='https://api.twitter.com/1.1/',
    request_token_url='https://api.twitter.com/oauth/request_token',
    access_token_url='https://api.twitter.com/oauth/access_token',
    authorize_url='https://api.twitter.com/oauth/authenticate',
コード例 #27
0
app = Flask(__name__)
app.secret_key = os.environ.get('PYB_100D_APP_SECRET') or sys.exit(
    'need secret app key')

oauth = OAuth(app)

# urllib.error.URLError: <urlopen error
#   [SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed (_ssl.c:749)>
ssl._create_default_https_context = ssl._create_unverified_context

twitter = oauth.remote_app(
    'twitter',
    consumer_key=os.environ.get('PYB_100D_TW_KEY') or sys.exit('need tw key'),
    consumer_secret=os.environ.get('PYB_100D_TW_SECRET')
    or sys.exit('need tw secret'),
    base_url='https://api.twitter.com/1.1/',
    request_token_url='https://api.twitter.com/oauth/request_token',
    access_token_url='https://api.twitter.com/oauth/access_token',
    authorize_url='https://api.twitter.com/oauth/authorize')


@twitter.tokengetter
def get_twitter_token():
    if 'twitter_oauth' in session:
        resp = session['twitter_oauth']
        return resp['oauth_token'], resp['oauth_token_secret']


@app.before_request
def before_request():
コード例 #28
0
from flask import Flask, request, redirect, url_for, flash, render_template
from flask_oauthlib.client import OAuth

app = Flask(__name__)
app.config['DEBUG'] = True
oauth = OAuth()
mySession = None
currentUser = None

app.secret_key = 'development'

twitter = oauth.remote_app('twitter',
                           base_url='https://api.twitter.com/1.1/',
                           request_token_url='https://api.twitter.com/oauth/request_token',
                           access_token_url='https://api.twitter.com/oauth/access_token',
                           authorize_url='https://api.twitter.com/oauth/authenticate',
                           consumer_key='xRxFoWzorAAgN8C2KGEUvFDdH',
                           consumer_secret='8PiaFxKpSHKYQNCpjd86Unwirlx5aW48Tn1YSB1a4q9Dx77EbI'
                           )


# Obtener token para esta sesion
@twitter.tokengetter
def get_twitter_token(token=None):
    global mySession

    if mySession is not None:
        return mySession['oauth_token'], mySession['oauth_token_secret']

# Limpiar sesion anterior e incluir la nueva sesion
@app.before_request
コード例 #29
0
def configure(app):
    """
    will build oauthlib remote apps from config vairable in form of

    OAUTH = {
        "google": {
            "consumer_key": 'xxxxxxxxxxxx',
            "consumer_secret": 'xxxxxxxxxxxxxxxxxxxx',
            "request_token_params": {
                'scope': ('https://www.googleapis.com/auth/userinfo.email '
                          'https://www.googleapis.com/auth/userinfo.profile')
            },
            "base_url": 'https://www.googleapis.com/oauth2/v1/',
            "request_token_url": None,
            "access_token_method": 'POST',
            "access_token_url": 'https://accounts.google.com/o/oauth2/token',
            "authorize_url": 'https://accounts.google.com/o/oauth2/auth',
            "_info_endpoint": "userinfo"
        },
        "facebook": {
            "consumer_key": "xxxxxxxxxxxxxxxxxxxxxxxx",
            "consumer_secret": "xxxxxxxxxxxxxxxxxxxxxxxxxx",
            "request_token_params": {'scope': 'email'},
            "base_url": 'https://graph.facebook.com',
            "request_token_url": None,
            "access_token_url": '/oauth/access_token',
            "authorize_url": 'https://www.facebook.com/dialog/oauth',
            "_info_endpoint": "/me"
        },
        "github": {},
        "linkedin": {},
        "dropbox": {},
        "twitter": {}
    }
    """

    app.add_quokka_url_rule(
        '/accounts/oauth/login/<provider>/',
        'oauth_login',
        oauth_login
    )

    config = app.config.get("OAUTH")
    if not config:
        return

    oauth = OAuth(app)

    for provider, data in config.items():
        provider_name = "oauth_" + provider
        oauth_app = oauth.remote_app(
            provider,
            **{k: v for k, v in data.items() if not k.startswith("_")}
        )

        token_var = "oauth_{}_token".format(provider)
        oauth_app.tokengetter(lambda: session.get(token_var))

        setattr(app, provider_name, oauth_app)

        app.add_quokka_url_rule(
            '/accounts/oauth/authorized/{0}/'.format(provider),
            '{0}_authorized'.format(provider),
            oauth_app.authorized_handler(make_oauth_handler(provider))
        )

        if provider == 'linkedin':
            def change_linkedin_query(uri, headers, body):
                auth = headers.pop('Authorization')
                headers['x-li-format'] = 'json'
                if auth:
                    auth = auth.replace('Bearer', '').strip()
                    if '?' in uri:
                        uri += '&oauth2_access_token=' + auth
                    else:
                        uri += '?oauth2_access_token=' + auth
                return uri, headers, body

            oauth_app.pre_request = change_linkedin_query
コード例 #30
0
ファイル: login.py プロジェクト: LastWulfStanding/pajbot
def init(app):
    oauth = OAuth(app)

    # enables the usage of 127.0.0.1:7221 over http for OAuth purposes.
    os.environ['OAUTHLIB_INSECURE_TRANSPORT'] = '1'

    twitch = oauth.remote_app(
        'twitch',
        consumer_key=app.bot_config['webtwitchapi']['client_id'],
        consumer_secret=app.bot_config['webtwitchapi']['client_secret'],
        request_token_params={
            'scope': 'user_read',
        },
        base_url='http://127.0.0.1:7221/kraken/',
        request_token_url=None,
        access_token_method='POST',
        access_token_url='https://id.twitch.tv/oauth2/token',
        authorize_url='https://id.twitch.tv/oauth2/authorize',
    )

    @app.route('/login')
    def login():
        callback_url = app.bot_config['webtwitchapi'][
            'redirect_uri'] if 'redirect_uri' in app.bot_config[
                'webtwitchapi'] else url_for('authorized', _external=True)
        state = request.args.get('n') or request.referrer or None
        return twitch.authorize(
            callback=callback_url,
            state=state,
        )

    @app.route('/login/error')
    def login_error():
        return render_template('login_error.html')

    @app.route('/login/authorized')
    def authorized():
        try:
            resp = twitch.authorized_response()
        except OAuthException:
            log.exception('An exception was caught while authorizing')
            next_url = get_next_url(request, 'state')
            return redirect(next_url)
        except:
            log.exception('Unhandled exception while authorizing')
            return render_template('login_error.html')

        print(resp)
        if resp is None:
            if 'error' in request.args and 'error_description' in request.args:
                log.warn('Access denied: reason={}, error={}'.format(
                    request.args['error'], request.args['error_description']))
            next_url = get_next_url(request, 'state')
            return redirect(next_url)
        elif type(resp) is OAuthException:
            log.warn(resp.message)
            log.warn(resp.data)
            log.warn(resp.type)
            next_url = get_next_url(request, 'state')
            return redirect(next_url)
        session['twitch_token'] = (resp['access_token'], )
        me = twitch.get('user')
        level = 100
        with DBManager.create_session_scope() as db_session:
            db_user = db_session.query(User).filter_by(
                username=me.data['name'].lower()).one_or_none()
            if db_user:
                level = db_user.level
        session['user'] = {
            'username': me.data['name'],
            'username_raw': me.data['display_name'],
            'level': level,
        }
        next_url = get_next_url(request, 'state')
        return redirect(next_url)

    def get_next_url(request, key='n'):
        next_url = request.args.get(key, '/')
        if next_url.startswith('//'):
            return '/'
        return next_url

    @app.route('/logout')
    def logout():
        session.pop('twitch_token', None)
        session.pop('user', None)
        next_url = get_next_url(request)
        if next_url.startswith('/admin'):
            next_url = '/'
        return redirect(next_url)

    @twitch.tokengetter
    def get_twitch_oauth_token():
        return session.get('twitch_token')

    def change_twitch_header(uri, headers, body):
        auth = headers.get('Authorization')
        if auth:
            auth = auth.replace('Bearer', 'OAuth')
            headers['Authorization'] = auth
        return uri, headers, body

    twitch.pre_request = change_twitch_header
コード例 #31
0
consumer_key = ''
consumer_secret = ''

basedir = os.path.abspath(os.path.dirname(__file__))

app = Flask(__name__)
# app.debug = True
app.config.from_object(__name__)
app.secret_key = os.urandom(24)

oauth = OAuth(app)
twitter = oauth.remote_app(
    'twitter',
    consumer_key = consumer_key,
    consumer_secret = consumer_secret,
    base_url = 'https://api.twitter.com/1.1/',
    request_token_url = 'https://api.twitter.com/oauth/request_token',
    access_token_url = 'https://api.twitter.com/oauth/access_token',
    authorize_url = 'https://api.twitter.com/oauth/authorize'
)

oauth.init_app(app)

@app.before_request
def before_reqeust():
    g.screen_name = None
    g.logged_in = False
    if 'user_info' in session:
        g.screen_name = session['user_info']['screen_name']

def get_verified_count():
コード例 #32
0
import os
from flask_oauthlib.client import OAuth
from flask import g

oauth = OAuth()

github = oauth.remote_app(
    'github',
    consumer_key=os.environ.get('GITHUB_CLIENT_ID'),
    consumer_secret=os.environ.get('GITHUB_SECRET_KEY'),
    request_token_params={"scope": "user:email"},
    base_url="https://api.github.com/",
    request_token_url=None,
    access_token_method="POST",
    access_token_url="https://github.com/login/oauth/access_token",
    authorize_url="https://github.com/login/oauth/authorize",
)


@github.tokengetter
def tokengetter():
    if 'access_token' in g:
        return g.access_token
コード例 #33
0
ファイル: app.py プロジェクト: web-Logic/TweetToPay
from flask import Flask, url_for, render_template, request, redirect, session
from flask_oauthlib.client import OAuth
import sqlite3

SECRET_KEY = 'development key'

app = Flask(__name__)
app.secret_key = SECRET_KEY
oauth = OAuth()
twitter = oauth.remote_app(
    'twitter',
    base_url='https://api.twitter.com/1/',
    request_token_url='https://api.twitter.com/oauth/request_token',
    access_token_url='https://api.twitter.com/oauth/access_token',
    authorize_url='https://api.twitter.com/oauth/authorize',
    consumer_key='NKHMeDZvNkJjZZtdp3dKrH7RH',
    consumer_secret='B5tmJXiMnFpmsLpifsRQ8BjbUfjDU7CnPkxp32E2c1bNzuTncQ')


@twitter.tokengetter
def get_twitter_token(token=None):
    return session.get('twitter_token')


@app.route('/')
def index():
    return render_template('index.html')


@app.route('/login', methods=['GET', 'POST'])
def login():
コード例 #34
0
ファイル: oa.py プロジェクト: solrac156/arac
import os

from dotenv import load_dotenv
from flask import g
from flask_oauthlib.client import OAuth

load_dotenv()

oauth = OAuth()

github = oauth.remote_app(
    "github",
    consumer_key=os.getenv("GITHUB_CONSUMER_KEY"),
    consumer_secret=os.getenv("GITHUB_CONSUMER_SECRET"),
    request_token_params={"scope": "user:email"},
    base_url="https://api.github.com",
    request_token_url=None,
    access_token_method="POST",
    access_token_url="https://github.com/login/oauth/access_token",
    authorize_url="https://github.com/login/oauth/authorize",
)


@github.tokengetter
def get_github_token():
    if "access_token" in g:
        return g.access_token
コード例 #35
0
ファイル: sample_oauth.py プロジェクト: nnbaokhang/ok
def create_client(app):
    oauth = OAuth(app)

    remote = oauth.remote_app(
        'ok-server',  # Server Name
        consumer_key='example-app',
        consumer_secret='example-secret',
        request_token_params={
            'scope': 'all',
            'state': lambda: security.gen_salt(10)
        },
        base_url=url + '/api/v3/',
        request_token_url=None,
        access_token_method='POST',
        access_token_url=url + '/oauth/token',
        authorize_url=url + '/oauth/authorize')

    # Real OK Server
    # remote = oauth.remote_app(
    #     'ok-server',  # Server Name
    #     consumer_key='example',
    #     consumer_secret='fake-secret-get-the-real-one',
    #     request_token_params={'scope': 'email',
    #                           'state': lambda: security.gen_salt(10)},
    #     base_url='https://okpy.org/api/v3/',
    #     request_token_url=None,
    #     access_token_method='POST',
    #     access_token_url='https://okpy.org/oauth/token',
    #     authorize_url='https://okpy.org/oauth/authorize'
    # )

    # def check_req(uri, headers, body):
    #     """ Add access_token to the URL Request. """
    #     if 'access_token' not in uri and session.get('dev_token'):
    #         params = {'access_token': session.get('dev_token')[0]}
    #         url_parts = list(urllib.parse.urlparse(uri))
    #         query = dict(urllib.parse.parse_qsl(url_parts[4]))
    #         query.update(params)
    #
    #         url_parts[4] = urllib.parse.urlencode(query)
    #         uri = urllib.parse.urlunparse(url_parts)
    #     return uri, headers, body
    # remote.pre_request = check_req

    @app.route('/')
    def index():
        if 'dev_token' in session:
            ret = remote.get('user', token=session['dev_token'])
            # User: ret.data['data']['email']
            return jsonify(ret.data)

        return redirect(url_for('login'))

    @app.route('/login')
    def login():
        return remote.authorize(callback=url_for('authorized', _external=True))

    @app.route('/logout')
    def logout():
        session.pop('dev_token', None)
        return redirect(url_for('index'))

    @app.route('/authorized')
    def authorized():
        resp = remote.authorized_response()
        if resp is None:
            return 'Access denied: error=%s' % (request.args['error'])
        if isinstance(resp, dict) and 'access_token' in resp:
            session['dev_token'] = (resp['access_token'], '')
            return jsonify(resp)
        return str(resp)

    @app.route('/user')
    def client_method():
        token = session['dev_token'][0]
        r = requests.get(url + '/api/v3/user/?access_token={}'.format(token))
        r.raise_for_status()
        return jsonify(r.json())

    @remote.tokengetter
    def get_oauth_token():
        return session.get('dev_token')

    return remote
コード例 #36
0
ファイル: core.py プロジェクト: adamchainz/aleph
from flask_oauthlib.client import OAuth
from flask_mail import Mail
from kombu import Exchange, Queue
from celery import Celery
from elasticsearch import Elasticsearch

from aleph import default_settings, archive
from aleph.ext import get_init

db = SQLAlchemy()
migrate = Migrate()
mail = Mail()
celery = Celery('aleph')
assets = Environment()
oauth = OAuth()
oauth_provider = oauth.remote_app('provider', app_key='OAUTH')


def create_app(config={}):
    app = Flask('aleph')
    app.config.from_object(default_settings)
    if config.get('TESTING'):
        app.config.from_envvar('ALEPH_TEST_SETTINGS', silent=True)
    else:
        app.config.from_envvar('ALEPH_SETTINGS', silent=True)
    app.config.update(config)
    app_name = app.config.get('APP_NAME')

    if not app.debug and app.config.get('MAIL_ADMINS'):
        credentials = (app.config.get('MAIL_USERNAME'),
                       app.config.get('MAIL_PASSWORD'))
コード例 #37
0
ファイル: auth.py プロジェクト: antaresc/la-la
import logging
import json

logger = logging.getLogger(__name__)

auth = Blueprint('auth', __name__)

# --------------------------- OAUTH SETUP ---------------------------

oauth = OAuth(app)

google_auth = oauth.remote_app(
    'google',
    consumer_key=app.config['GOOGLE_CLIENT_ID'],
    consumer_secret=app.config['GOOGLE_CLIENT_SECRET'],
    request_token_params={'scope': "email"},
    base_url='https://www.googleapis.com/oauth2/v3/',
    request_token_url=None,
    access_token_method='POST',
    access_token_url='https://accounts.google.com/o/oauth2/token',
    authorize_url='https://accounts.google.com/o/oauth2/auth')


@google_auth.tokengetter
def get_access_token():
    return session.get('google_token')


# --------------------------- HELPER FUNCTIONS ---------------------------


def user_from_google_token(token):
コード例 #38
0
ファイル: site.py プロジェクト: Mitame/sr-bridge
from .rocket import User
from . import config, app, data, rocket

from flask import render_template, session, flash, redirect, url_for, request
from flask_oauthlib.client import OAuth
from hashlib import sha256
import requests
oauth = OAuth()

slack_oauth = oauth.remote_app(
    "slack",
    base_url="https://slack.com/api/",
    access_token_url="https://slack.com/api/oauth.access",
    authorize_url="https://slack.com/oauth/authorize",
    consumer_key=config["slack"]["oauth"]["client_id"],
    consumer_secret=config["slack"]["oauth"]["client_secret"],
    request_token_params={"scope": "chat:write:user"},
)


@slack_oauth.tokengetter
def slack_tokengetter():
    return session.get("slack_token")


@app.route("/slack_oauth")
def site_slack_oauth():
    return slack_oauth.authorize(callback="https://dev.mita.me/slack_callback")


@app.route("/slack_callback")
コード例 #39
0
ファイル: config.py プロジェクト: jtomaszk/MyCashmanager
from flask_sqlalchemy import SQLAlchemy
from flask_oauthlib.client import OAuth

__author__ = 'jtomaszk'


db = SQLAlchemy()
oauth = OAuth()
google = oauth.remote_app('google',
                          app_key='GOOGLE',
                          request_token_params={
                              'scope': 'email'
                          },
                          # base_url='https://www.googleapis.com/oauth2/v1/',
                          base_url='https://www.googleapis.com/oauth2/',
                          request_token_url=None,
                          access_token_method='POST',
                          access_token_url='https://accounts.google.com/o/oauth2/token',
                          authorize_url='https://accounts.google.com/o/oauth2/auth'
                          )



コード例 #40
0
import os
import json
from flask import Flask, redirect, url_for, session, request, jsonify, Markup
from flask_oauthlib.client import OAuth
from config import Config

app = Flask(__name__)
app.debug = True
app.secret_key = 'development'
oauth = OAuth(app)

qq = oauth.remote_app(
    'qq',
    consumer_key=Config.QQ_APP_ID,
    consumer_secret=Config.QQ_APP_KEY,
    base_url='https://graph.qq.com',
    request_token_url=None,
    request_token_params={'scope': 'get_user_info'},
    access_token_url='/oauth2.0/token',
    authorize_url='/oauth2.0/authorize',
)


def json_to_dict(x):
    '''OAuthResponse class can't parse the JSON data with content-type
-    text/html and because of a rubbish api, we can't just tell flask-oauthlib to treat it as json.'''
    if x.find(b'callback') > -1:
        # the rubbish api (https://graph.qq.com/oauth2.0/authorize) is handled here as special case
        pos_lb = x.find(b'{')
        pos_rb = x.find(b'}')
        x = x[pos_lb:pos_rb + 1]
コード例 #41
0
ファイル: auth.py プロジェクト: pombredanne/jobs-3
"""Authorization token handling functions."""

from flask import session
from flask_oauthlib.client import OAuth
import f8a_jobs.defaults as configuration

oauth = OAuth()
github = oauth.remote_app(
    'github',
    consumer_key=configuration.GITHUB_CONSUMER_KEY,
    consumer_secret=configuration.GITHUB_CONSUMER_SECRET,
    request_token_params={'scope': 'user:email,read:org'},
    base_url='https://api.github.com/',
    request_token_url=None,
    access_token_method='POST',
    access_token_url='https://github.com/login/oauth/access_token',
    authorize_url='https://github.com/login/oauth/authorize'
)


@github.tokengetter
def get_github_oauth_token():
    """Return the authorization token to GitHub."""
    return session.get('auth_token')
コード例 #42
0
from flask_restful import Api
from flask_sqlalchemy import SQLAlchemy

from backend.config import EnvironmentConfig


def format_url(endpoint):
    parts = "/".join([i for i in endpoint.split("/") if i])
    return "/api/{}/{}/".format(EnvironmentConfig.API_VERSION, parts)


db = SQLAlchemy()
migrate = Migrate()
oauth = OAuth()

osm = oauth.remote_app("osm", app_key="OSM_OAUTH_SETTINGS")

# Import all models so that they are registered with SQLAlchemy
from backend.models.postgis import *  # noqa


def create_app(env=None):
    """
    Bootstrap function to initialise the Flask app and config
    :return: Initialised Flask app
    """

    app = Flask(__name__, )

    # Load configuration options from environment
    app.config.from_object("backend.config.EnvironmentConfig")
コード例 #43
0
import os
from logging.handlers import RotatingFileHandler

from flask import Flask
from flask_cors import CORS
from flask_migrate import Migrate
from flask_oauthlib.client import OAuth
from flask_restful import Api
from flask_sqlalchemy import SQLAlchemy

db = SQLAlchemy()
migrate = Migrate()
oauth = OAuth()

osm = oauth.remote_app(
    'osm',
    app_key='OSM_OAUTH_SETTINGS'
)

# Import all models so that they are registered with SQLAlchemy
from server.models.postgis import *  # noqa


def create_app(env=None):
    """
    Bootstrap function to initialise the Flask app and config
    :return: Initialised Flask app
    """
    app = Flask(__name__)

    if env is None:
        env = os.getenv('TM_ENV', 'Dev')  # default to Dev if config environment var not set
コード例 #44
0
ファイル: app.py プロジェクト: tmuehl/saiki-pemetaan
        client_credentials = json.load(fd)

oauth_api_endpoint = os.getenv('ACCESS_TOKEN_URL', '')
oauth_tokeninfo_endpoint = os.getenv('TOKENINFO_URL', '')

if oauth_api_endpoint == '':
    logging.error("no OAuth Endpoint provided. Exiting ...")
    exit(1)

auth = oauth.remote_app(
    'auth',
    consumer_key=client_credentials['client_id'],
    consumer_secret=client_credentials['client_secret'],
    request_token_params={'scope': 'uid'},
    base_url=oauth_api_endpoint,
    request_token_url=None,
    access_token_method='POST',
    access_token_url=oauth_api_endpoint + '/oauth2/' +
                                          'access_token?realm=employees',
    authorize_url=oauth_api_endpoint + '/oauth2/'
                                       'authorize?realm=employees'
)

# AppConfig(app, configfile)
# Flask-Appconfig is not necessary, but
# highly recommend =)
# https://github.com/mbr/flask-appconfig
Bootstrap(app)

# in a real app, these should be configured through Flask-Appconfig
app.config['SECRET_KEY'] = 'devkey'
コード例 #45
0
ファイル: application.py プロジェクト: linklab/flask_rest
application.config['WTF_CSRF_SECRET_KEY'] = os.urandom(24)
application.config['SECRET_KEY'] = os.urandom(24)

login_manager = LoginManager()
login_manager.init_app(application)

logging.basicConfig(filename='test.log', level=logging.DEBUG)

application.secret_key = 'development'
oauth = OAuth(application)
github = oauth.remote_app(
    name='github',
    consumer_key='a11a1bda412d928fb39a',
    consumer_secret='92b7cf30bc42c49d589a10372c3f9ff3bb310037',
    request_token_params={'scope': 'user:email'},
    base_url='https://api.github.com/',
    request_token_url=None,
    access_token_method='POST',
    access_token_url='https://github.com/login/oauth/access_token',
    authorize_url='https://github.com/login/oauth/authorize')


@login_manager.user_loader
def load_user(user_id):
    q = base.db_session.query(User).filter(User.id == user_id)
    user = q.first()

    if user is not None:
        user._authenticated = True
    return user
コード例 #46
0
import flask
from flask_login import LoginManager
from flask_migrate import Migrate
from flask_oauthlib.client import OAuth
from flask_sqlalchemy import SQLAlchemy

db = SQLAlchemy()
login_manager = LoginManager()
oauth = OAuth()


slack_oauth = oauth.remote_app('slack',
                               base_url='https://api.slack.com',
                               request_token_url=None,
                               access_token_url='https://slack.com/api/oauth.access',  # noqa
                               authorize_url='https://slack.com/oauth/authorize',  # noqa
                               app_key='SLACK',
                               request_token_params=dict(
                                   scope='identity.basic'
                               ))


@slack_oauth.tokengetter
def _get_slack_token():
    return flask.session.get('slack_token'), ''


def init_app(app):
    """
    Initialize the external application dependencies
コード例 #47
0
# coding: utf-8

import os
from flask import session
from flask_oauthlib.client import OAuth

_oauth = OAuth()
_flask_oauthlib_twitter = _oauth.remote_app('twitter',
    consumer_key = os.getenv('TWITTER_CONSUMER_KEY'),
    consumer_secret = os.getenv('TWITTER_CONSUMER_SECRET'),
    access_token_url='https://api.twitter.com/oauth/access_token',
    authorize_url='https://api.twitter.com/oauth/authorize',
    request_token_url='https://api.twitter.com/oauth/request_token',
    base_url='https://api.twitter.com/1.1/')

twitter = _flask_oauthlib_twitter

# https://flask-oauthlib.readthedocs.org/en/latest/client.html
@twitter.tokengetter
def get_twitter_token():
    return session.get('user', {}).get('twitter_credentials')

# https://flask-oauthlib.readthedocs.org/en/latest/client.html
def log_session_in():
    """ Save OAuth AT/ATS info into session. """
    resp = twitter.authorized_response()
    at, ats = resp['oauth_token'], resp['oauth_token_secret']
    session['user'] = {'twitter_credentials': (at, ats)}
コード例 #48
0
# Edited by S. Adams for Designing Software for the Web to add comments and remove flash messaging

app = Flask(__name__)

app.debug = True #Change this to False for production

app.secret_key = os.environ['SECRET_KEY'] #use SECRET_KEY to sign session cookies
oauth = OAuth(app)

# Set up GitHub as OAuth provider
github = oauth.remote_app(
    'github',
    consumer_key=os.environ['GITHUB_CLIENT_ID'], #your web apps "username" for OAuth
    consumer_secret=os.environ['GITHUB_CLIENT_SECRET'], # web apps "password" for OAUTh
    request_token_params={'scope': 'user:email'}, #request read-only access to the user's email.  For a list of possible scopes, see developer.github.com/apps/building-oauth-apps/scopes-for-oauth-apps
    base_url='https://api.github.com/',
    request_token_url=None,
    access_token_method='POST',
    access_token_url='https://github.com/login/oauth/access_token',  
    authorize_url='https://github.com/login/oauth/authorize' #URL for github's OAuth login
)

#context  processors run before templates are rendered and add variables to the template context
#context processors must return a dictionary
#this context processor adds the variable logged_in to the context for all temlates
@app.context_processor
def inject_logged_in():
    return {"logged_in":('github_token' in session)}

@app.route('/')
def home():
コード例 #49
0
def create_oauth_client(app, name, **kwargs):
    """Helper function to create a OAuth2 client to test an OAuth2 provider."""
    blueprint = Blueprint('oauth2test', __name__, template_folder='templates')

    default = dict(
        consumer_key='confidential',
        consumer_secret='confidential',
        request_token_params={'scope': 'test:scope'},
        request_token_url=None,
        access_token_method='POST',
        access_token_url='/oauth/token',
        authorize_url='/oauth/authorize',
        content_type='application/json',
    )
    default.update(kwargs)

    oauth = OAuth(app)
    remote = oauth.remote_app(name, **default)

    @blueprint.route('/oauth2test/login')
    def login():
        return remote.authorize(callback=url_for('oauth2test.authorized',
                                                 _external=True))

    @blueprint.route('/oauth2test/logout')
    def logout():
        session.pop('confidential_token', None)
        return "logout"

    @blueprint.route('/oauth2test/authorized')
    @remote.authorized_handler
    def authorized(resp):
        if resp is None:
            return 'Access denied: error=%s' % (
                request.args.get('error', "unknown")
            )
        if isinstance(resp, dict) and 'access_token' in resp:
            session['confidential_token'] = (resp['access_token'], '')
            return jsonify(resp)
        return str(resp)

    def get_test(test_url):
        if 'confidential_token' not in session:
            abort(403)
        else:
            ret = remote.get(test_url)
            if ret.status != 200:
                return abort(ret.status)
            return ret.raw_data

    @blueprint.route('/oauth2test/test-ping')
    def test_ping():
        return get_test(url_for("invenio_oauth2server.ping"))

    @blueprint.route('/oauth2test/test-info')
    def test_info():
        return get_test(url_for('invenio_oauth2server.info'))

    @blueprint.route('/oauth2test/test-invalid')
    def test_invalid():
        return get_test(url_for('invenio_oauth2server.invalid'))

    @remote.tokengetter
    def get_oauth_token():
        return session.get('confidential_token')

    app.register_blueprint(blueprint)

    return remote
コード例 #50
0
ファイル: __init__.py プロジェクト: nikete/tweet-scorer
from flask import Flask
from flask.ext.sqlalchemy import SQLAlchemy
from flask.ext.login import LoginManager
from config import basedir

from flask_oauthlib.client import OAuth

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

lm = LoginManager()
lm.init_app(app)
lm.login_view = 'login'
lm.refresh_view = 'refresh'

oauth = OAuth(app)

twitter = oauth.remote_app(
    'twitter',
    consumer_key='tqC2q3KhStpJ14H90BqNg',
    consumer_secret='c4uaYwUkpSYIvGUjCQAj80z8GcowPwtK896GN8BjM',
    base_url='https://api.twitter.com/1.1/',
    request_token_url='https://api.twitter.com/oauth/request_token',
    access_token_url='https://api.twitter.com/oauth/access_token',
    authorize_url='https://api.twitter.com/oauth/authenticate',
)

from app import views, models

コード例 #51
0
ファイル: github.py プロジェクト: wujtruj/gitstars
from flask import Flask, redirect, url_for, session, request, jsonify
from flask_oauthlib.client import OAuth


app = Flask(__name__)
app.debug = True
app.secret_key = 'development'
oauth = OAuth(app)

github = oauth.remote_app(
    'gitstars',
    consumer_key='6ce4569a00ce43c79fb2',
    consumer_secret='e073c7ddc205d5e6ea7ce36801bc5f2caa2a25c9',
    request_token_params={'scope': 'user:email'},
    base_url='https://api.github.com/',
    request_token_url=None,
    access_token_method='POST',
    access_token_url='https://github.com/login/oauth/access_token',
    authorize_url='https://github.com/login/oauth/authorize'
)


@app.route('/')
def index():
    if 'github_token' in session:
        me = github.get('user')
        return jsonify(me.data)
    return redirect(url_for('login'))


@app.route('/login')
コード例 #52
0
from Driver import Driver
import json
import collections

app = Flask(__name__)
#app.debug = True
app.secret_key = 'development'

oauth = OAuth(app)
my_dr_global = Driver()

github = oauth.remote_app(
    'github',
    consumer_key='9668bff6a6d0cf60d387',
    consumer_secret='1adfdb0718d49e1f33bb68376ef439658c5f947d',
    request_token_params={'scope': 'user:email'},
    base_url='https://api.github.com/',
    request_token_url=None,
    access_token_method='POST',
    access_token_url='https://github.com/login/oauth/access_token',
    authorize_url='https://github.com/login/oauth/authorize')


def _decode_list(data):
    rv = []
    for item in data:
        if isinstance(item, unicode):
            item = item.encode('utf-8')
        elif isinstance(item, list):
            item = _decode_list(item)
        elif isinstance(item, dict):
            item = _decode_dict(item)
コード例 #53
0
ファイル: core.py プロジェクト: nivertech/aleph
from celery import Celery
from py2neo import Graph
from elasticsearch import Elasticsearch

from aleph import default_settings, archive
from aleph.ext import get_init

log = logging.getLogger(__name__)

db = SQLAlchemy()
migrate = Migrate()
mail = Mail()
celery = Celery('aleph')
assets = Environment()
oauth = OAuth()
oauth_provider = oauth.remote_app('provider', app_key='OAUTH')


def create_app(config={}):
    app = Flask('aleph')
    app.config.from_object(default_settings)
    if config.get('TESTING'):
        app.config.from_envvar('ALEPH_TEST_SETTINGS', silent=True)
    else:
        app.config.from_envvar('ALEPH_SETTINGS', silent=True)
    app.config.update(config)
    app_name = app.config.get('APP_NAME')

    if not app.debug and app.config.get('MAIL_ADMINS'):
        credentials = (app.config.get('MAIL_USERNAME'),
                       app.config.get('MAIL_PASSWORD'))
コード例 #54
0
import urllib.parse
import re

from flask import Flask, redirect, url_for, session, jsonify, request
from flask_oauthlib.client import OAuth, OAuthException
from sqlalchemy import create_engine, MetaData

app = Flask(__name__)
from app import config

oauth = OAuth(app)
zeus = oauth.remote_app(
    'zeus',
    consumer_key=app.config['OAUTH_KEY'],
    consumer_secret=app.config['OAUTH_SECRET'],
    request_token_params={},
    base_url='https://adams.ugent.be/oauth/api/',
    access_token_method='POST',
    access_token_url='https://adams.ugent.be/oauth/oauth2/token/',
    authorize_url='https://adams.ugent.be/oauth/oauth2/authorize/')

tab_engine = create_engine(app.config['TAB_DB_URL'],
                           convert_unicode=True,
                           pool_pre_ping=True)
tab_metadata = MetaData(bind=tab_engine)

tap_engine = create_engine(app.config['TAP_DB_URL'],
                           convert_unicode=True,
                           pool_pre_ping=True)
tap_metadata = MetaData(bind=tap_engine)
コード例 #55
0
ファイル: views.py プロジェクト: akarim78/HighFly
import urllib2
from xml.dom import minidom
from glassdoor import get

app.debug = True
app.secret_key = 'development'
oauth = OAuth(app)
#75ovm95gewyled
#VZwnHKUuyCXNX0to
linkedin = oauth.remote_app(
    'linkedin',
    consumer_key='75ovm95gewyled',
    consumer_secret='VZwnHKUuyCXNX0to',
    request_token_params={
        'scope': 'r_basicprofile,r_fullprofile,r_emailaddress,r_contactinfo,r_network',
        'state': 'RandomString',
    },
    base_url='https://api.linkedin.com/v1/',
    request_token_url=None,
    access_token_method='POST',
    access_token_url='https://www.linkedin.com/uas/oauth2/accessToken',
    authorize_url='https://www.linkedin.com/uas/oauth2/authorization',
)



@app.route('/')
def index():
    if 'linkedin_token' in session:
        me = linkedin.get('people/~:(first-name,last-name,headline,picture-url,public-profile-url,formatted-name,summary,skills,email-address,main-address,phone-numbers,industry)')
        # user=User(nickname="ahsan",email="*****@*****.**")
        # db.session.add(user)
コード例 #56
0
GOOGLE_ID='180871412866-i8algb2ticev3q7kfb9k6m07pn3j0vvk.apps.googleusercontent.com'
GOOGLE_SECRET='8ZH4qN1t2-7dsJmGHn3LfDWU'

app.config['GOOGLE_ID'] = "180871412866-i8algb2ticev3q7kfb9k6m07pn3j0vvk.apps.googleusercontent.com"
app.config['GOOGLE_SECRET'] = "8ZH4qN1t2-7dsJmGHn3LfDWU"
app.debug = True
app.secret_key = 'development'
oauth = OAuth(app)

google = oauth.remote_app(
    'google',
    consumer_key=app.config.get('GOOGLE_ID'),
    consumer_secret=app.config.get('GOOGLE_SECRET'),
    request_token_params={
        'scope': 'email'
    },
    base_url='https://www.googleapis.com/oauth2/v1/',
    request_token_url=None,
    access_token_method='POST',
    access_token_url='https://accounts.google.com/o/oauth2/token',
    authorize_url='https://accounts.google.com/o/oauth2/auth',
)


#APP_ROOT = os.path.dirname(os.path.abspath(__file__))

@app.route("/")
def index():
	if 'role' in session:
		role=session['role']
		if role=='admin':
コード例 #57
0
from flask import Flask, redirect, url_for, session, request, jsonify
from flask_oauthlib.client import OAuth


app = Flask(__name__)
app.debug = True
app.secret_key = 'development'
oauth = OAuth(app)

linkedin = oauth.remote_app(
    'linkedin',
    consumer_key='k8fhkgkkqzub',
    consumer_secret='ZZtLETQOQYNDjMrz',
    request_token_params={
        'scope': 'r_basicprofile',
        'state': 'RandomString',
    },
    base_url='https://api.linkedin.com/v1/',
    request_token_url=None,
    access_token_method='POST',
    access_token_url='https://www.linkedin.com/uas/oauth2/accessToken',
    authorize_url='https://www.linkedin.com/uas/oauth2/authorization',
)


@app.route('/')
def index():
    if 'linkedin_token' in session:
        me = linkedin.get('people/~')
        return jsonify(me.data)
    return redirect(url_for('login'))
コード例 #58
0
app.debug = False

app.secret_key = os.environ['APP_SECRET_KEY']
oauth = OAuth(app)

# This code originally from https://github.com/lepture/flask-oauthlib/blob/master/example/github.py
# Edited by P. Conrad for SPIS 2016 to add getting Client Id and Secret from
# environment variables, so that this will work on Heroku.


github = oauth.remote_app(
    'github',
    consumer_key=os.environ['GITHUB_CLIENT_ID'],
    consumer_secret=os.environ['GITHUB_CLIENT_SECRET'],
    request_token_params={'scope': 'read:org'},
    base_url='https://api.github.com/',
    request_token_url=None,
    access_token_method='POST',
    access_token_url='https://github.com/login/oauth/access_token',
    authorize_url='https://github.com/login/oauth/authorize'
)


@app.context_processor
def inject_logged_in():
    return dict(logged_in=('github_token' in session))

@app.context_processor
def inject_github_org():
    return dict(github_org=os.getenv('GITHUB_ORG'))
コード例 #59
0
ファイル: views.py プロジェクト: bartlett705/microblog
from forms import EditUserForm, PostForm, SearchForm, EditPostForm
from app import app, db, lm
from models import User, Post
from flask_oauthlib.client import OAuth
from flask.ext.login import login_user, logout_user, current_user, login_required
from flask.ext.misaka import markdown

@lm.user_loader
def load_user(id):
    return User.query.get(int(id))

oauth = OAuth()
fb_oauth = oauth.remote_app('facebook',
        base_url='https://graph.facebook.com/',
        request_token_url=None,
        access_token_url='/oauth/access_token',
        authorize_url='https://www.facebook.com/dialog/oauth',
        consumer_key=app.config['OAUTH_CREDENTIALS']['facebook']['id'],
        consumer_secret=app.config['OAUTH_CREDENTIALS']['facebook']['secret'],
        request_token_params={'scope': 'email, public_profile'})

tw_oauth = oauth.remote_app('twitter',
    base_url='https://api.twitter.com/1/',
    request_token_url='https://api.twitter.com/oauth/request_token',
    access_token_url='https://api.twitter.com/oauth/access_token',
    authorize_url='https://api.twitter.com/oauth/authorize',
    consumer_key=app.config['OAUTH_CREDENTIALS']['twitter']['id'],
    consumer_secret=app.config['OAUTH_CREDENTIALS']['twitter']['secret']
)

gg_oauth = oauth.remote_app('google',
                          base_url='https://www.google.com/accounts/',
コード例 #60
0
@APP.errorhandler(Exception)
def handle_auth_error(ex):
    response = jsonify(message=ex.message)
    return response


oauth = OAuth(APP)

auth0 = oauth.remote_app(
    'auth0',
    consumer_key=AUTH0_CLIENT_ID,
    consumer_secret=AUTH0_CLIENT_SECRET,
    request_token_params={
        'scope': 'openid profile',
        'audience': AUTH0_AUDIENCE
    },
    base_url='https://%s' % AUTH0_DOMAIN,
    access_token_method='POST',
    access_token_url='/oauth/token',
    authorize_url='/authorize',
)


def requires_auth(f):
    @wraps(f)
    def decorated(*args, **kwargs):
        if constants.PROFILE_KEY not in session:
            return redirect('/login')
        return f(*args, **kwargs)