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 __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
