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()
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
예제 #3
0
from flask import g, redirect, request, session, flash, url_for, render_template
from flask_openid import OpenID
from flask_oauth import OAuth
from penguicontrax import constants
from . import lookup_current_user, User
from .. import app, db
from ..constants import constants
import urllib, hashlib

oid = OpenID(app, constants.OPENID_STORE, safe_roots=[])
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=constants.TWITTER_KEY,
    consumer_secret=constants.TWITTER_SECRET_KEY
)
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=constants.FACEBOOK_APP_ID,
    consumer_secret=constants.FACEBOOK_SECRET,
    request_token_params={'scope': 'email'}
)

def gravatar_image_update(user):
    default_small = constants.PUBLIC_URL + 'static/penguinhead_small.png'
예제 #4
0
app.config.from_pyfile('settings.cfg')
app.debug = app.config['DEBUG']
boto_logger = logging.getLogger('boto')
handler = RotatingFileHandler(app.config['LOG_DIR'] + '/' + __name__ + '.log',
                              maxBytes=10000,
                              backupCount=1)
if app.config['DEBUG'] == 'True':
    handler.setLevel(logging.DEBUG)
    boto_logger.setLevel(logging.DEBUG)
else:
    # Force TLS and HSTS only in production
    sslify = SSLify(app, permanent=True)
    handler.setLevel(logging.INFO)
app.logger.addHandler(handler)
db = SQLAlchemy(app)
oid = OpenID(app)

app.logger.info(
    'App started with debug mode: {0}\nApp running with Flask: {1}'.format(
        app.config['DEBUG'], app.config['USE_FLASK']))


class Role(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    role = db.relationship('User', backref='user')
    name = db.Column(db.String(40))

    @staticmethod
    def get_or_create(role_name):
        rv = Role.query.filter_by(name=role_name).first()
        if rv is None:
예제 #5
0
from flask_openid import OpenID


LOGIN_URL = "https://login.ubuntu.com"

app = FlaskBase(
    __name__,
    "anbox-cloud.io",
    template_folder="../templates",
    static_folder="../static",
    template_404="404.html",
    template_500="500.html",
)

app.secret_key = os.environ["SECRET_KEY"]
open_id = OpenID(stateless=True, safe_roots=[])


def login_required(func):
    """
    Decorator that checks if a user is logged in, and redirects
    to login page if not.
    """

    @functools.wraps(func)
    def is_user_logged_in(*args, **kwargs):
        if "openid" not in flask.session:
            return flask.redirect("/login?next=" + flask.request.path)

        return func(*args, **kwargs)
예제 #6
0
from flask_openid import OpenID
from flask_migrate import Migrate

from cfg.configuration import load_config
from models import db


def create_app():
    """Factory to create the Flask application with cfg and db."""
    app = Flask(__name__)
    load_config(app.config)
    db.init_app(app)
    return app

app = create_app()
oid = OpenID(app, store_factory=lambda: None)
migrate = Migrate(app, db)

##########
# Routes #
##########

@app.route('/docs/<path:path>')
def access_docs(path):
    return send_from_directory('docs', path)

from routes.user import build_api_user
from routes.auth import build_api_auth
from routes.game import build_api_game

build_api_auth(app, oid)
예제 #7
0
#encoding: utf-8

from flask_bcrypt import Bcrypt
from flask_login import LoginManager
from flask_openid import OpenID
from flask_mail import Mail
from flask_cache import Cache
from flask_restful import Api

bcrypt = Bcrypt()

openid = OpenID()

mail = Mail()

cache = Cache()

restful_api = Api()

# Create the Flask-Login's instance
login_manager = LoginManager()
login_manager.login_view = "main.login"
login_manager.session_protection = "strong"
login_manager.login_message = "Please login to access this page."
login_manager.login_message_category = "info"


@login_manager.user_loader
def load_user(user_id):
    """Load the user's info."""
예제 #8
0
from os.path import dirname, join
from flask import Flask, g, redirect, session, json
from flask_sqlalchemy import SQLAlchemy
from flask_openid import OpenID
import urllib, urllib2
import re

app = Flask(__name__)
app.config.update(SQLALCHEMY_DATABASE_URI='sqlite:///flask-openid.db',
                  SECRET_KEY='STEAM API KEY',
                  DEBUG=True,
                  PORT=5000)

oid = OpenID(app, join(dirname(__file__), 'openid_store'))
db = SQLAlchemy(app)


class User(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    steam_id = db.Column(db.String(40))
    nickname = db.Column(db.String(80))

    @staticmethod
    def get_or_create(steam_id):
        rv = User.query.filter_by(steam_id=steam_id).first()
        if rv is None:
            rv = User()
            rv.steam_id = steam_id
            dbs.session.add(rv)
        return rv
예제 #9
0
from requests.exceptions import RequestException
from urllib.parse import urlparse, parse_qs
from random import randint

app = flask.Flask(__name__)
app.secret_key = os.environ['SECRET_KEY']

# Setup session to retry requests 5 times
uncached_session = requests.Session()
retries = Retry(total=5,
                backoff_factor=0.1,
                status_forcelist=[500, 502, 503, 504])
uncached_session.mount('https://api.snapcraft.io',
                       HTTPAdapter(max_retries=retries))

oid = OpenID(app, safe_roots=[], extension_responses=[MacaroonResponse])

# The cache expires after 5 seconds
cached_session = requests_cache.CachedSession(expire_after=5)

# Requests should timeout after 2 seconds in total
request_timeout = 2

# Request only stable snaps
snap_details_url = ("https://api.snapcraft.io/api/v1/snaps/details/{snap_name}"
                    "?channel=stable")
details_query_headers = {
    'X-Ubuntu-Series': '16',
    'X-Ubuntu-Architecture': 'amd64',
}
예제 #10
0
from flask_login import LoginManager  # takes care of the inputs and user handling

# create an application object
from config import basedir, MAIL_PASSWORD, MAIL_USERNAME, MAIL_PORT, MAIL_SERVER, ADMINS

app = Flask(__name__)
app.config.from_object('config')  # why is this coming from 'config' object?

# SQLAlchemy is Python SQL toolkit and Object Relational Mapper
db = SQLAlchemy(app)
# the views are the handlers that response to requests from web browser or other clients

lm = LoginManager()
lm.init_app(app)
lm.login_view = 'login'  # this is the view that logs the user in
oid = OpenID(app, os.path.join(basedir, "tmp"))

# enabling email to be sent when there is an error
if not app.debug:
    import logging
    from logging.handlers import SMTPHandler
    credentials = None
    if MAIL_USERNAME or MAIL_PASSWORD:
        credentials = (MAIL_USERNAME, MAIL_PASSWORD)
    mail_handler = SMTPHandler((MAIL_SERVER, MAIL_PORT), 'no-reply@' + MAIL_SERVER, ADMINS, "app failure", credentials)
    mail_handler.setLevel(logging.ERROR)
    app.logger.addHandler(mail_handler)


# enable logging to a file
if not app.debug:
예제 #11
0
파일: app.py 프로젝트: lsjwzh/SteamLens
import json
import os.path
import re
from datetime import datetime
from urllib.parse import urlencode
from urllib.request import urlopen

import requests
from flask import Flask, render_template, redirect, session, g
from flask_openid import OpenID
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)
app.config.from_envvar('STEAMLENS_SETTINGS')

oid = OpenID(app, os.path.join(os.path.dirname(__file__), app.config['OPENID_STIRE']))
db = SQLAlchemy(app)


#######################
# Recommender Service #
#######################

@app.context_processor
def inject_current_time():
    return {'current_time': datetime.utcnow()}


@app.route('/')
def index():
    return redirect('/pop')
예제 #12
0
app = flask.Flask(__name__)
if "COPRS_ENVIRON_PRODUCTION" in os.environ:
    app.config.from_object("coprs.config.ProductionConfig")
elif "COPRS_ENVIRON_UNITTEST" in os.environ:
    app.config.from_object("coprs.config.UnitTestConfig")
else:
    app.config.from_object("coprs.config.DevelopmentConfig")
if os.environ.get("COPR_CONFIG"):
    app.config.from_envvar("COPR_CONFIG")
else:
    app.config.from_pyfile("/etc/copr/copr.conf", silent=True)

app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True

oid = OpenID(app,
             app.config["OPENID_STORE"],
             safe_roots=[],
             extension_responses=[TeamsResponse])

db = SQLAlchemy(app)


@contextmanager
def db_session_scope():
    """Provide a transactional scope around a series of operations."""
    session = db.session
    try:
        yield session
        session.commit()
    except Exception as err:
        session.rollback()
        raise
예제 #13
0
from flask_openid import OpenID

import anitya.lib
import anitya.mail_logging

__version__ = '0.11.0'

# Create the application.
APP = flask.Flask(__name__)

APP.config.from_object('anitya.default_config')
if 'ANITYA_WEB_CONFIG' in os.environ:  # pragma: no cover
    APP.config.from_envvar('ANITYA_WEB_CONFIG')

# Set up OpenID
APP.oid = OpenID(APP)

# Set up the logging
logging_config = {
    'version': 1,
    'disable_existing_loggers': False,
    'formatters': {
        'simple': {
            'format': '[%(name)s %(levelname)s] %(message)s',
        },
    },
    'handlers': {
        'console': {
            'class': 'logging.StreamHandler',
            'formatter': 'simple',
            'stream': 'ext://sys.stdout',
예제 #14
0
"""
Config can be either of 
DevelopmentConfig
ProductionConfig
TestingConfig
"""
app.config.from_object('core.config.DevelopmentConfig')
"""
Internationalization support
"""
babel = Babel(app)
"""
OpenID instance
"""
openid_store = "logs"
oid = OpenID(app, openid_store)
"""
Helper modules for app
"""
from core import context_processors, loggers
"""
Create cookie to track activities if user is not logged in
Value in this cookie will be used as temporary userid in words, descriptions, views, likes and dislikes
"""


@app.before_request
def create_temp_userid_cookie():
    session.permanent = True
    app.permanent_session_lifetime = timedelta(days=31)
    if 'openid' not in session:
예제 #15
0
from flask import Flask, redirect, request, jsonify  # session?
from flask_openid import OpenID
from flask_cors import cross_origin
from Battlerite import teams, players, matches, telemetry
from Database.MongoDB import mongodb
from Database.ORM import champion, tournament, test
from Steam.Steam import getSInfo

app = Flask(__name__)
openID = OpenID(app)

app.config.update(
    SECRET_KEY=
    'static',  # os.urandom(24), <-- can be used to use random keys(not api)
    DEBUG=True,
    TESTING=True)
db = mongodb.initialise_database(app)
#app.steamUser = None


@app.route("/steam", methods=["GET"])
@openID.loginhandler
def login():
    return openID.try_login('http://steamcommunity.com/openid')


@openID.after_login
def after_login(response):
    #return "plz - {}".format(getSInfo(response))
    return redirect(openID.get_next_url() +
                    '?{}'.format(getSInfo(response)['steamid']))
예제 #16
0
파일: app.py 프로젝트: gold1617/FitFinder
from flask import Flask, render_template, request, g, session, flash, redirect, url_for, abort, jsonify
from flask_openid import OpenID
from openid.extensions import pape

from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.orm import scoped_session, sessionmaker
from sqlalchemy.ext.declarative import declarative_base

app = Flask(__name__)
app.config.update(DATABASE_URI='sqlite:///database.db',
                  SECRET_KEY='dev key',
                  DEBUG='true')

oid = OpenID(app, safe_roots=[], extension_responses=[pape.Response])

# setup sqlalchemy
engine = create_engine(app.config['DATABASE_URI'])
db_session = scoped_session(
    sessionmaker(autocommit=False, autoflush=True, bind=engine))

Base = declarative_base()
Base.query = db_session.query_property()


def init_db():
    Base.metadata.create_all(bind=engine)


class User(Base):
    __tablename__ = 'users'
    id = Column(Integer, primary_key=True)
예제 #17
0
def before_request():
    g.user = current_user
    g.oid = OpenID(app, os.path.join(basedir, 'tmp'))
예제 #18
0
import os
from flask_login import LoginManager
from flask_openid import OpenID
from config import dirCurrent
'''

Application Configuration

'''

app = Flask(__name__)
app.config.from_object('config')
db = SQLAlchemy(app)
lm = LoginManager()
lm.init_app(app)
oid = OpenID(app, os.path.join(dirCurrent, 'tmp'))

#placed here to prevent circular imports
from models import *
'''

Controller - Handling the routes.

'''


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

예제 #19
0
LOGIN_URL = "https://login.ubuntu.com"
ANBOXCLOUD_API_BASE = "https://demo-api.anbox-cloud.io"

session = requests.Session()
app = FlaskBase(
    __name__,
    "anbox-cloud.io",
    template_folder="../templates",
    static_folder="../static",
    template_404="404.html",
    template_500="500.html",
)

app.secret_key = os.environ["SECRET_KEY"]
open_id = OpenID(stateless=True,
                 safe_roots=[],
                 extension_responses=[MacaroonResponse])

# Discourse docs
session = talisker.requests.get_session()

discourse_docs = Docs(
    parser=DocParser(
        api=DiscourseAPI(base_url="https://discourse.ubuntu.com/",
                         session=session),
        index_topic_id=17029,
        url_prefix="/docs",
    ),
    document_template="docs/document.html",
    url_prefix="/docs",
)
예제 #20
0
                               'no-reply@' + MAIL_SERVER, ADMINS,
                               'microblog failure', credentials)
    mail_handler.setLevel(logging.ERROR)
    app.logger.addHandler(mail_handler)

if not app.debug:
    import logging
    from logging.handlers import RotatingFileHandler
    file_handler = RotatingFileHandler('tmp/microblog.log', 'a',
                                       1 * 1024 * 1024, 10)
    file_handler.setFormatter(
        logging.Formatter(
            '%(asctime)s %(levelname)s: %(message)s [in %(pathname)s:%(lineno)d]'
        ))
    app.logger.setLevel(logging.INFO)
    file_handler.setLevel(logging.INFO)
    app.logger.addHandler(file_handler)
    app.logger.info('microblog startup')

#Login
lm = LoginManager()
lm.init_app(app)
lm.login_view = 'login'
oid = OpenID(app, os.path.join(basedir,
                               'tmp'))  #path donde guardaremos los archivos

#conexion BDD
db = SQLAlchemy(app)

from app import views, models
#importamos las vistas, lo hacemos al final para evitar referencias circulares
예제 #21
0
from app.form import LoginForm, EditForm, PostForm
from flask_login import LoginManager, login_required, login_user, logout_user, current_user
from datetime import datetime
from pprint import pprint
from app import app
from app.models import User, Post
from app.config import Config
from flask_login import LoginManager
from flask_openid import OpenID
from app.models import db
import os

lm = LoginManager()
lm.init_app(app)
lm.login_view = 'login'
oid = OpenID(app,
             os.path.join(os.path.abspath(os.path.dirname(__file__)), 'tmp'))


@app.before_request
def before_request():
    g.user = current_user
    if g.user.is_authenticated:
        g.user.last_seen = datetime.utcnow()
        db.session.add(g.user)
        db.session.commit()


#openID装饰器
@lm.user_loader
def load_user(id):
    return User.query.get(int(id))
예제 #22
0
    def __init__(self, appbuilder):
        super(BaseSecurityManager, self).__init__(appbuilder)
        app = self.appbuilder.get_app
        # Base Security Config
        app.config.setdefault('AUTH_ROLE_ADMIN', 'Admin')
        app.config.setdefault('AUTH_ROLE_PUBLIC', 'Public')
        app.config.setdefault('AUTH_TYPE', AUTH_DB)
        # Self Registration
        app.config.setdefault('AUTH_USER_REGISTRATION', False)
        app.config.setdefault('AUTH_USER_REGISTRATION_ROLE',
                              self.auth_role_public)

        # LDAP Config
        if self.auth_type == AUTH_LDAP:
            if 'AUTH_LDAP_SERVER' not in app.config:
                raise Exception(
                    "No AUTH_LDAP_SERVER defined on config with AUTH_LDAP authentication type."
                )
            app.config.setdefault('AUTH_LDAP_SEARCH', '')
            app.config.setdefault('AUTH_LDAP_SEARCH_FILTER', '')
            app.config.setdefault('AUTH_LDAP_BIND_USER', '')
            app.config.setdefault('AUTH_LDAP_APPEND_DOMAIN', '')
            app.config.setdefault('AUTH_LDAP_USERNAME_FORMAT', '')
            app.config.setdefault('AUTH_LDAP_BIND_PASSWORD', '')
            # TLS options
            app.config.setdefault('AUTH_LDAP_USE_TLS', False)
            app.config.setdefault('AUTH_LDAP_ALLOW_SELF_SIGNED', False)
            app.config.setdefault('AUTH_LDAP_TLS_DEMAND', False)
            app.config.setdefault('AUTH_LDAP_TLS_CACERTDIR', '')
            app.config.setdefault('AUTH_LDAP_TLS_CACERTFILE', '')
            app.config.setdefault('AUTH_LDAP_TLS_CERTFILE', '')
            app.config.setdefault('AUTH_LDAP_TLS_KEYFILE', '')
            # Mapping options
            app.config.setdefault('AUTH_LDAP_UID_FIELD', 'uid')
            app.config.setdefault('AUTH_LDAP_FIRSTNAME_FIELD', 'givenName')
            app.config.setdefault('AUTH_LDAP_LASTNAME_FIELD', 'sn')
            app.config.setdefault('AUTH_LDAP_EMAIL_FIELD', 'mail')

        if self.auth_type == AUTH_OID:
            self.oid = OpenID(app)
        if self.auth_type == AUTH_OAUTH:
            from flask_oauthlib.client import OAuth
            self.oauth = OAuth()
            self.oauth_remotes = dict()
            for _provider in self.oauth_providers:
                provider_name = _provider['name']
                log.debug("OAuth providers init {0}".format(provider_name))
                obj_provider = self.oauth.remote_app(provider_name,
                                                     **_provider['remote_app'])
                obj_provider._tokengetter = self.oauth_tokengetter
                if not self.oauth_user_info:
                    self.oauth_user_info = self.get_oauth_user_info
                # Whitelist only users with matching emails
                if 'whitelist' in _provider:
                    self.oauth_whitelists[provider_name] = _provider[
                        'whitelist']
                self.oauth_remotes[provider_name] = obj_provider

        self.lm = LoginManager(app)
        self.lm.login_view = 'login'
        self.lm.user_loader(self.load_user)
예제 #23
0
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
from config import base_dir
from flask import Flask
from flask_login import LoginManager
from flask_openid import OpenID
from flask_sqlalchemy import SQLAlchemy
from os import path

app = Flask(__name__)
app.config.from_object('config')
db = SQLAlchemy(app)
lm = LoginManager()
lm.init_app(app)
lm.login_view='login'
oid = OpenID(app,path.join(base_dir,'tmp'))

from app import views
from app import models
예제 #25
0
        '{0}:{1}'.format(app.config["MEMCACHED_HOST"],
                         app.config["MEMCACHED_PORT"])
    ],
                                 key_prefix=app.config["MEMCACHED_KEY_PREFIX"])
elif app.config["CACHE_TYPE"].lower() == "simple":
    flask_cache = SimpleCache()
else:
    flask_cache = NullCache()

if app.config["PROXY_SETUP"]:
    app.wsgi_app = ProxyFix(app.wsgi_app)

if app.config["OPENID_ENABLED"]:
    from flask_openid import OpenID
    from openid_teams import teams
    oid = OpenID(app, safe_roots=[], extension_responses=[teams.TeamsResponse])
    from webfaf.login import login  # pylint: disable=cyclic-import
    app.register_blueprint(login)
    from webfaf.user import user  # pylint: disable=cyclic-import
    app.register_blueprint(user)

from webfaf.reports import reports  # pylint: disable=wrong-import-position, cyclic-import
app.register_blueprint(reports, url_prefix="/reports")
from webfaf.problems import problems  # pylint: disable=wrong-import-position, cyclic-import
app.register_blueprint(problems, url_prefix="/problems")
from webfaf.stats import stats  # pylint: disable=wrong-import-position, cyclic-import
app.register_blueprint(stats, url_prefix="/stats")
from webfaf.summary import summary  # pylint: disable=wrong-import-position, cyclic-import
app.register_blueprint(summary, url_prefix="/summary")

예제 #26
0
import datanommer.models

# Create the application.
app = flask.Flask(__name__)
log = app.logger

app.url_map.converters['not_reserved'] = fmn.web.converters.NotReserved

# set up FAS
app.config.from_object('fmn.web.default_config')
if 'FMN_WEB_CONFIG' in os.environ:  # pragma: no cover
    app.config.from_envvar('FMN_WEB_CONFIG')

# Set up OpenID in stateless mode
oid = OpenID(app,
             safe_roots=[],
             store_factory=lambda: None,
             url_root_as_trust_root=True)

# Inject a simple jinja2 test -- it is surprising jinja2 does not have this.
app.jinja_env.tests['equalto'] = lambda x, y: x == y

# Also, allow 'continue' and 'break' statements in jinja loops
app.jinja_env.add_extension('jinja2.ext.loopcontrols')

db_url = config.app_conf['fmn.sqlalchemy.uri']

fedmsg.meta.make_processors(**config.app_conf)

# Long, long ago
# http://threebean.org/blog/datanommer-and-fedmsg-activity/
before_fedmsg = datetime.datetime(2012, 10, 8)
예제 #27
0
from flask import flash, redirect, url_for, session
from flask_bcrypt import Bcrypt
from flask_openid import OpenID
from flask_oauth import OAuth
from flask_login import LoginManager, login_required
from flask_principal import Principal, Permission, RoleNeed
from flask_restful import Api
from flask_celery import Celery

admin_permission = Permission(RoleNeed('admin'))
poster_permission = Permission(RoleNeed('poster'))
default_permission = Permission(RoleNeed('default'))
from celery.backends.redis import RedisBackend
oid = OpenID()
login_manager = LoginManager()
login_manager.login_view = "main.login"
login_manager.session_protection = "strong"
login_manager.login_message = "Please login to access this page"
login_manager.login_message_category = "info"
bcrypt = Bcrypt()
rest_api = Api()
principals = Principal()
celery = Celery()


@login_manager.user_loader
def load_user(userid):
    from .models import User
    return User.query.get(userid)

예제 #28
0
from flask import render_template, session, redirect, flash, url_for, request, g
from flask_wtf import FlaskForm
from wtforms import BooleanField, StringField, SubmitField
from wtforms.validators import DataRequired
from flask_login import login_user, logout_user, current_user
from app import bp, db, lm, oid
from app.models import User, ROLE_USER
from flask_openid import OpenID

oid = OpenID(bp, os.path.join(BASEDIR, 'tmp'))


class LoginForm(FlaskForm):
    openid = StringField('openid', validators=[DataRequired()])
    submit = SubmitField('Submit')
    remember_me = BooleanField('Remember_me', default=False)


# 从数据库加载用户
@lm.user_loader
def load_user(uid):
    return User.query.get(int(uid))


# Flask-Login设定的全局变量current_user复制给g变量
@bp.before_request
def before_request():
    g.user = current_user


# 装饰器:oid.loginhandler 告诉Flask-OpenID这是登录视图函数
예제 #29
0
if sys.getdefaultencoding() != defaultencoding:
    reload(sys)
    sys.setdefaultencoding(defaultencoding)

logging.basicConfig(filename='cmdb.log', level=logging.ERROR)
logging.info('Started')
app = Flask(__name__)
logging.info('App established')
#读取config配置
app.config.from_object('config')
# 初始化Flask-Bootstap扩展
bootstrap = Bootstrap()
mail = Mail()
moment = Moment()

login_manager = LoginManager()
login_manager.session_protection = 'strong'
login_manager.login_view = 'cmdb.login'
oid = OpenID(app, os.path.join(basedir, 'tmp'))

app.config.from_object(config['default'])
config['default'].init_app(app)
bootstrap.init_app(app)
mail.init_app(app)
moment.init_app(app)
db = SQLAlchemy(app)
db.init_app(app)
login_manager.init_app(app)

from app import views, models
예제 #30
0
import os
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from flask_login import LoginManager
from flask_openid import OpenID
from config import basedir


app = Flask(__name__)
#instruct flask to read & use config file
app.config.from_object('config')

db = SQLAlchemy(app) #the db
lm = LoginManager()
lm.init_app(app)
lm.login_view = 'login'
oid = OpenID(app, '/path/to/store', safe_roots=[])
#oid = OpenID(app, os.path.join(basedir, 'tmp'))

from app import views, models
예제 #31
0
from flask import render_template, flash, redirect, session, url_for, request, g
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from flask_openid import OpenID
import config
from hashlib import md5
import os

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(config.basedir, 'tmp'))

followers = db.Table(
    "followers", db.Column("follower_id", db.Integer,
                           db.ForeignKey("user.id")),
    db.Column("followed_id", db.Integer, db.ForeignKey("user.id")))


class User(db.Model):
    global followers
    id = db.Column(db.Integer, primary_key=True)
    nickname = db.Column(db.String(64), index=True, unique=True)
    email = db.Column(db.String(120), index=True, unique=True)
    posts = db.relationship('Post', backref='author', lazy='dynamic')
    about_me = db.Column(db.String(140))
    last_seen = db.Column(db.DateTime)
    followed = db.relationship("User",
예제 #32
0
파일: app.py 프로젝트: fomichevic/TD
import eventlet

eventlet.monkey_patch()

from flask_socketio import SocketIO
from flask import Flask, g, session, request, flash, render_template, redirect, abort, url_for
from flask_openid import OpenID
from config import off
from db import create_db, create_user, update_score, users_top, find_user, all_db, user_status



app = Flask(__name__)
app.config.from_object('config')
socketio = SocketIO(app, async_mode='eventlet')
oid = OpenID(app, 'tmp')


def login_required(func):
    def before_request(*args, **kwargs):
        if g.user is None:
            return redirect('login')
        return func(*args, **kwargs)
    before_request.__name__ = func.__name__
    return before_request


@app.route('/top')
@login_required
def top():
    default_start, default_amount = 0, 100