def __init__(self, app, install=True, prefix=None, name='GoogleAuth'): self.app = app self.app.config.setdefault('GOOGLE_DOMAIN', None) self.oid = OpenID(self.app) self.url_prefix = prefix self.name = name self.blueprint = self._get_blueprint(self.name) self.domain = self.app.config.get('GOOGLE_DOMAIN') self._login = self.oid.loginhandler(self.__login) self._create_or_login = self.oid.after_login(self.__create_or_login) if install: self.install()
# -*- coding: utf-8 -*- from demoprovider import app from models import ResourceOwner as User from models import db_session from flask import g, session, render_template, request, redirect, flash from flask import abort, url_for from flaskext.openid import OpenID # setup flask-openid oid = OpenID(app) @app.before_request def before_request(): g.user = None if 'openid' in session: g.user = User.query.filter_by(openid=session['openid']).first() @app.after_request def after_request(response): db_session.remove() return response @app.route('/') def index(): return render_template('index.html') @app.route('/login', methods=['GET', 'POST'])
import flask import yaml import os from flaskext.openid import OpenID from wtforms import BooleanField, TextField, FloatField, HiddenField from wtforms import SelectField, Form, validators from .database import add_point, del_point, submit_points_to_osm import database oid = OpenID() class EditPointForm(Form): name = TextField('name', [validators.Required()]) url = TextField('url') lat = FloatField('lat', [validators.NumberRange(min=-90, max=90)]) lon = FloatField('lon', [validators.NumberRange(min=-180, max=180)]) ops_file = os.path.join(os.path.dirname(__file__), 'amenities.yaml') options = yaml.load(file(ops_file, 'r')) for i, j in enumerate(options): options[i] = tuple(options[i]) amenity = SelectField('amenity', choices=options) new_amenity = TextField('new_amenity') id = HiddenField('id', [validators.Optional()]) frontend = flask.Blueprint('frontend', __name__)
# ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. # The views and conclusions contained in the software and documentation are those of the # authors and should not be interpreted as representing official policies, either expressed # or implied, of Baiju M <*****@*****.**>. from flask import Flask from flaskext.sqlalchemy import SQLAlchemy from flaskext.openid import OpenID from flaskext.gravatar import Gravatar app = Flask(__name__) app.config.from_object('py3k.config.DevelopmentConfig') db = SQLAlchemy(app) oid = OpenID(app, app.config['OPENID_FS_STORE_PATH']) gravatar = Gravatar(app, size=20, rating='g', default='retro', force_default=False, force_lower=False) import model import auth import packages import nonpypi import captcha import main
# -*- coding: utf-8 -*- from grasscms.main import * from grasscms.models import Page, User, Blog from flaskext.openid import OpenID oid = OpenID(app) def check_form(name, email, page_name, subdomain): possible_blog = Blog.query.filter_by(subdomain=subdomain).first() if not name: flash(u'Error: you have to provide a name') elif '@' not in email: # TODO: Do this with wtf forms. flash(u'Error: you have to enter a valid email address') elif possible_blog is not None and g.user.blog != possible_blog.id: flash(u'Error: That page name is already taken') else: return True return False @app.before_request def before_request(): g.user = None g.user_is_admin = None if 'openid' in session: g.user = User.query.filter_by(openid=session['openid']).first() @app.after_request def after_request(response): db_session.remove() db_session.commit() return response
from flask import Flask, g, request, Response, redirect, render_template, session from flaskext.openid import OpenID #from pymongo import Connection from process import process from log import L, snip from processors.mongodb_proxy import DB from flask.helpers import url_for from internal_db_ops import internal_find, internal_save import urllib app = Flask(__name__) app.config.update(SECRET_KEY='my-very-secretive-secret', ) oid = OpenID(app, '/tmp/', fallback_endpoint='http://api.yeda.us') @app.before_request def before_request(): g.db = DB() g.app = app g.user = None if 'openid' in session: openid_key = urllib.quote(urllib.quote(session['openid'], safe='')) user = internal_find('/data/admin/users/%s' % openid_key) if user != None: g.user = user @app.after_request def after_request(response): g.db.after_request() response.headers["Access-Control-Allow-Origin"] = "*"
class GoogleAuth(object): """Google Federated Authentication manager. If ``install==True`` (default), it is automatically installed into the given Flask application. """ def __init__(self, app, install=True, prefix=None, name='GoogleAuth'): self.app = app self.app.config.setdefault('GOOGLE_DOMAIN', None) self.oid = OpenID(self.app) self.url_prefix = prefix self.name = name self.blueprint = self._get_blueprint(self.name) self.domain = self.app.config.get('GOOGLE_DOMAIN') self._login = self.oid.loginhandler(self.__login) self._create_or_login = self.oid.after_login(self.__create_or_login) if install: self.install() def _check_auth(self): """Returns True if authentication is valid.""" return ('openid' in session) if self.domain else True def __login(self): return self.oid.try_login('https://www.google.com/accounts/o8/site-xrds?hd=%s' % self.domain) def _before_request(self): g.user = None def __create_or_login(self, resp): """This is called when login with OpenID succeeded and it's not necessary to figure out if this is the users's first login or not. This function has to redirect otherwise the user will be presented with a terrible URL which we certainly don't want. """ session['openid'] = resp.identity_url return redirect(self.oid.get_next_url()) def _logout(self): session.pop('openid', None) return redirect(self.oid.get_next_url()) def _get_blueprint(self, name): return Blueprint( name, __name__, static_folder=os.path.join(current_dir, 'static'), template_folder=os.path.join(current_dir, 'templates'), ) def _configure_routes(self): self.blueprint.route('/login/', methods=['GET', 'POST'])(self._login) self.blueprint.route('/logout/', methods=['GET', 'POST'])(self._logout) def _register_blueprint(self, **kwargs): self.app.register_blueprint( self.blueprint, url_prefix=self.url_prefix, **kwargs ) def install(self): """Installs the Blueprint into the app.""" self.app.before_request(self._before_request) self._configure_routes() self._register_blueprint() def required(self, f): """Request decorator. Forces authentication.""" @wraps(f) def decorated(*args, **kwargs): auth = request.authorization if not self._check_auth(): return redirect(url_for('%s.__login' % self.blueprint.name, next=request.url)) return f(*args, **kwargs) return decorated
# -*- coding:utf-8 -*- from flask import (Blueprint, current_app, request, g, session, redirect, flash, render_template, url_for) from flask.ext.login import login_user, logout_user from flask.ext.principal import Identity, identity_changed from flask.ext.security import current_user, login_required from flask.ext.security.utils import get_post_login_redirect from flask.ext.security.exceptions import UserNotFoundError, BadCredentialsError from flaskext.openid import OpenID mod = Blueprint('openid', __name__, url_prefix='/openid') oid = OpenID() def init_blueprint(state): app = state.app oid.init_app(app) def _do_login(user, remember=True): if login_user(user, remember): identity_changed.send(current_app._get_current_object(), identity=Identity(user.id)) current_app.logger.debug('User %s logged in' % user) return True current_app.logger.debug('User %s failed login' % user) return False @mod.before_request def lookup_current_user():
class GoogleAuth(object): """Google Federated Authentication manager. If ``install==True`` (default), it is automatically installed into the given Flask application. """ def __init__(self, app, install=True, prefix=None, name='GoogleAuth'): self.app = app self.app.config.setdefault('GOOGLE_DOMAIN', None) self.oid = OpenID(self.app) self.url_prefix = prefix self.name = name self.blueprint = self._get_blueprint(self.name) self.domain = self.app.config.get('GOOGLE_DOMAIN') self._login = self.oid.loginhandler(self.__login) self._create_or_login = self.oid.after_login(self.__create_or_login) if install: self.install() def _check_auth(self): """Returns True if authentication is valid.""" return ('openid' in session) if self.domain else True def __login(self): return self.oid.try_login( 'https://www.google.com/accounts/o8/site-xrds?hd=%s' % self.domain) def _before_request(self): g.user = None def __create_or_login(self, resp): """This is called when login with OpenID succeeded and it's not necessary to figure out if this is the users's first login or not. This function has to redirect otherwise the user will be presented with a terrible URL which we certainly don't want. """ session['openid'] = resp.identity_url return redirect(self.oid.get_next_url()) def _logout(self): session.pop('openid', None) return redirect(self.oid.get_next_url()) def _get_blueprint(self, name): return Blueprint( name, __name__, static_folder=os.path.join(current_dir, 'static'), template_folder=os.path.join(current_dir, 'templates'), ) def _configure_routes(self): self.blueprint.route('/login/', methods=['GET', 'POST'])(self._login) self.blueprint.route('/logout/', methods=['GET', 'POST'])(self._logout) def _register_blueprint(self, **kwargs): self.app.register_blueprint(self.blueprint, url_prefix=self.url_prefix, **kwargs) def install(self): """Installs the Blueprint into the app.""" self.app.before_request(self._before_request) self._configure_routes() self._register_blueprint() def required(self, f): """Request decorator. Forces authentication.""" @wraps(f) def decorated(*args, **kwargs): auth = request.authorization if not self._check_auth(): return redirect( url_for('%s.__login' % self.blueprint.name, next=request.url)) return f(*args, **kwargs) return decorated
import os from flask import Flask from flask.ext.sqlalchemy import SQLAlchemy from flask_login import LoginManager from flaskext.openid import OpenID from config import basedir app = Flask(__name__) app.config.from_object('config') db = SQLAlchemy(app) lm = LoginManager() lm.init_app(app) lm.login_view = 'login' oid = OpenID(app, os.path.join(basedir, 'tmp')) from app import views, models