Esempio n. 1
1
def unauthorized_redirect(app):
    lm = LoginManager()
    lm.login_view = "login"
    lm.setup_app(app)
    res = lm.unauthorized()
    assert res.headers["Location"] == "/login?next=%2F"
    assert LOGIN_MESSAGE in get_flashed_messages()
Esempio n. 2
0
def init_app():
    app = Flask(__name__, static_url_path="/static")
    env = Environment(loader=FileSystemLoader("templates/"))

    app.config.from_object("FLASKCONFIG")

    login_manager = LoginManager()
    login_manager.init_app(app)

    @login_manager.user_loader
    def load_user(id):
        return User(int(id))

    app.register_blueprint(auth_blueprint, url_prefix="")
    app.register_blueprint(api_blueprint, url_prefix="/api/")

    @app.route("/t/<int:id>", methods=["GET"])
    @app.route("/register", methods=["GET"])
    @app.route("/login", methods=["GET"])
    @app.route("/create", methods=["GET"])
    @app.route("/", methods=["GET"])
    def index(id=0):
        return render_template("index.html")

    return app
Esempio n. 3
0
class LoginInSessionTestCase(unittest.TestCase):
    ''' Tests for login_user_in_session function '''

    def setUp(self):
        self.app = Flask(__name__)
        self.app.config['SECRET_KEY'] = 'deterministic'
        self.login_manager = LoginManager()
        self.login_manager.init_app(self.app)

        unittest.TestCase.setUp(self)

    def test_login_user_in_session(self):
        with self.app.test_request_context():
            session = {}
            login_user_in_session(session, notch)
            self.assertTrue('user_id' in session)
            self.assertTrue('_fresh' in session)
            self.assertTrue('_id' in session)
            self.assertTrue('remember' not in session)

    def test_login_user_in_session_remember(self):
        with self.app.test_request_context():
            session = {}
            login_user_in_session(session, notch, remember=True)
            self.assertTrue('user_id' in session)
            self.assertTrue('_fresh' in session)
            self.assertTrue('_id' in session)
            self.assertTrue(session['remember'])
Esempio n. 4
0
File: run.py Progetto: DianQ/MyCode
def configure_login(app):
    lm = LoginManager()
    lm.setup_app(app)

    @lm.user_loader
    def load_user(userid):
        return UserDAO.get(userid)
Esempio n. 5
0
class MethodViewLoginTestCase(unittest.TestCase):
    def setUp(self):
        self.app = Flask(__name__)
        self.login_manager = LoginManager()
        self.login_manager.init_app(self.app)
        self.login_manager._login_disabled = False

        class SecretEndpoint(MethodView):
            decorators = [
                login_required,
                fresh_login_required,
            ]

            def options(self):
                return u''

            def get(self):
                return u''

        self.app.add_url_rule('/secret',
                              view_func=SecretEndpoint.as_view('secret'))

    def test_options_call_exempt(self):
        with self.app.test_client() as c:
            result = c.open('/secret', method='OPTIONS')
            self.assertEqual(result.status_code, 200)
Esempio n. 6
0
def init_login(app):
    login_manager = LoginManager()
    login_manager.init_app(app)

    @login_manager.user_loader
    def load_user(user_id):
        return User.objects(id=user_id).first()
Esempio n. 7
0
def setup_app(app):
    """Setup login extension."""

    app.config.setdefault('CFG_OPENID_AUTHENTICATION', False)
    app.config.setdefault('CFG_OAUTH1_AUTHENTICATION', False)
    app.config.setdefault('CFG_OAUTH2_AUTHENTICATION', False)

    @app.errorhandler(401)
    def do_login_first(error=401):
        """Displays login page when user is not authorised."""
        if request.is_xhr:
            return g._("Authorization failure"), 401
        if current_user.is_guest:
            flash(g._("Please sign in to continue."), 'info')
        else:
            flash(g._("Authorization failure."), 'danger')
        from invenio.modules.accounts.views.accounts import login
        return login(referer=request.url), 401

    # Let's create login manager.
    _login_manager = LoginManager(app)
    _login_manager.login_view = app.config.get('CFG_LOGIN_VIEW',
                                               'webaccount.login')
    _login_manager.anonymous_user = UserInfo
    _login_manager.unauthorized_handler(do_login_first)

    @_login_manager.user_loader
    def _load_user(uid):
        """
        Function should not raise an exception if uid is not valid
        or User was not found in database.
        """
        return UserInfo(int(uid))

    return app
Esempio n. 8
0
def create_app(config_filename=None):
    app = Flask(__name__)
    app.config.from_pyfile(config_filename or 'config.py')
    if 'CERTIFICATOR_SETTINGS' in os.environ:
        # Only try to load a config from it if set.
        app.config.from_envvar('CERTIFICATOR_SETTINGS')

    from .db import get_user_by_id, get_user
    login_manager = LoginManager()
    login_manager.user_loader(get_user_by_id)
    login_manager.init_app(app)

    browser_id = BrowserID()
    browser_id.user_loader(get_user)
    browser_id.init_app(app)

    Bootstrap(app)

    from .db import db as sqla
    sqla.init_app(app)
    sqla.app = app

    sqla.create_all()

    import stripe
    stripe.api_key = app.config['STRIPE_SECRET_KEY']

    from .views import root, quiz, dashboard, certificate
    app.register_blueprint(root)
    app.register_blueprint(quiz)
    app.register_blueprint(dashboard)
    app.register_blueprint(certificate)

    return app
Esempio n. 9
0
def init_login():
    login_manager = LoginManager()
    login_manager.init_app(app)

    @login_manager.user_loader
    def load_user(user_id):
        return db.session.query(User).get(user_id)
Esempio n. 10
0
def create_app():
    global app
    global db
    global login_manager

    # Flask
    app = Flask(__name__)
    app.config.from_object('config.flask_config')

    # SQLAlchemy
    db = SQLAlchemy(app)

    # Login
    login_manager = LoginManager(app)
    login_manager.login_view = 'users.login'

    # Assets
    assets = Environment(app)
    less = Bundle('less/*.less',
                  filters='less',
                  output='css/gen/style.css',
                  depends='less/*.less')
    assets.register('less_all', less)

    # Debug
    app.config['DEBUG'] = (len(argv) == 2 and argv[1] == 'debug')

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

    register_blueprints(app)
    return app, db
Esempio n. 11
0
def create_app():
    global app
    global db
    global login_manager

    # Flask
    app = Flask(__name__,
                static_folder='static/dist/',
                static_url_path='/static')
    app.config.from_object('config.flask_config')

    # SQLAlchemy
    db = SQLAlchemy(app)

    # Login
    login_manager = LoginManager(app)
    login_manager.login_view = 'users.login'

    # Debug
    app.config['DEBUG'] = (len(argv) == 2 and argv[1] == 'debug')

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

    from app.models import AnonymousUser
    login_manager.anonymous_user = AnonymousUser

    register_blueprints(app)
    return app, db
Esempio n. 12
0
def app_factory(config):
    # create app
    app = Flask(__name__)
    app.config.from_object(config)

    # database
    db.init_app(app)
    whoosh_index(app, Post)

    # flask-login
    login_manager = LoginManager(app)
    login_manager.user_loader(load_user)

    # flask-wtf csrf protection
    CsrfProtect(app)

    # jinja2 config
    jinja.init_app(app)

    # blueprints
    from blog import blog
    app.register_blueprint(blog)

    from api import api
    app.register_blueprint(api, url_prefix='/api')

    return app
Esempio n. 13
0
def setup_login_manager(app):
    """ setup_login_manager::flask.Flask->None

        Creates a login manager object and attaches an application
        object to it.

        Also sets up the login view function to redirect to, and
        the user_loader function.

    """

    login_manager = LoginManager()
    login_manager.init_app(app)
    login_manager.login_view = 'facebook.login'
    login_manager.login_message_category = 'warning'

    @login_manager.user_loader
    def load_user(user_id):
        try:
            # we need a request context for a valid db connection
            with current_app.test_request_context('/'):
                db = g.db
                user = db.session.query(User).filter(User.UUID == user_id).one()
                return user
        except NoResultFound as e:
            current_app.logger.debug(e)
            return None
Esempio n. 14
0
class CApp(flask.Flask):
    """
    Main Crossco app. Made singleton to force one instance per server.
    """
    __metaclass__ = Singleton
    def __init__(self, import_name='', static_path=None, static_url_path=None,
                 static_folder='static', template_folder='templates',
                 instance_path=None, instance_relative_config=False):
        flask.Flask.__init__(self, import_name,
                                     static_path=static_path,
                                     static_url_path=static_url_path,
                                     static_folder=static_folder,
                                     template_folder=template_folder,
                                     instance_path=instance_path,
                                     instance_relative_config=instance_relative_config
                                     )
        self.config.update(config)
        self.db = flask.ext.sqlalchemy.SQLAlchemy(self)
        self.fb = 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=self.config['FACEBOOK_APP_ID'],
                consumer_secret=self.config['FACEBOOK_APP_SECRET'],
                request_token_params={'scope': 'email,manage_pages'})
        self.api_manager = APIManager(self, flask_sqlalchemy_db=self.db)
        self.login_manager = LoginManager()
        self.login_manager.setup_app(self)

    def run(self, host=None, port=None, debug=None, **options):
        self.db.create_all()
        flask.Flask.run(self, host, port, debug, **options)
Esempio n. 15
0
def create_app():
    global db

    app = Flask(__name__)

    app.config.from_object(wemedia.settings)

    db = DB(app)

    setup_blueprints(app)
    setup_logger(app)

    # 登录管理器
    login_manager = LoginManager()
    login_manager.setup_app(app)
    login_manager.login_view = 'Common.login'
    login_manager.login_message = u'请登录'

    @login_manager.user_loader
    def load_user(userid):
        from wemedia.common.models import User

        user = User.query.get(userid)

        return user

    return app
Esempio n. 16
0
class AuthenticationModule(SystemModule):
    def __init__(self, *args, **kwargs):
        super(AuthenticationModule, self).__init__(*args, **kwargs)
        self.login_manager = LoginManager()
        self.login_manager.login_message_category = "warning"
        self.login_manager.user_loader(self.load_user)
        self.logged_in_menu = DropdownMenu()
        self.login_text = mydomain.lazy_gettext('Login...')
        self.logged_in_user_text = mydomain.lazy_gettext('User: '******'.' + view.__name__
        return view

    def register(self, app, *args, **kwargs):
        super(AuthenticationModule, self).register(app, *args, **kwargs)
        self.login_manager.init_app(app)

    def login_url(self):
        return login_url(self.login_manager.login_view,
                         request.url)

    def logged_in_text(self):
        return self.logged_in_user_text + ' ' + self.get_current_user_name()

    def get_current_user_name(self):
        return current_user.get_name()

    def user_menu(self, text, group='', values={}):
        def wrap(view):
            name = self.name + '.' + view.__name__
            entry = self.menu_entry_for_view(view, text, values=values)
            self.logged_in_menu.add_entry(name, entry, group)
            return view
        return wrap

    def get_anonymous_system_menu(self):
        return MenuItem(text=self.login_text,
                        url=self.login_url())
    

    def get_system_menu_item(self):
        if current_user.is_anonymous():
            return self.get_anonymous_system_menu()
        else:
            return MenuItem(text=self.logged_in_text(),
                            items=self.logged_in_menu.build_real_menu())

    def handle_forbidden_endpoint(self):
        if current_user.is_anonymous():
            return self.login_manager.unauthorized()
        else:
            return self.forbidden()

    def forbidden(self):
        return abort(403)
    def __init__(self, app, user_repository):
        self.user_repository = user_repository

        login_manager = LoginManager()
        login_manager.user_loader(self.user_repository.get_by_username)
        login_manager.setup_app(app)

        self.login_manager = login_manager
Esempio n. 18
0
def register_login(app):
	login_manager = LoginManager()
	login_manager.login_view = 'account.login'
	login_manager.init_app(app)

	@login_manager.user_loader
	def load_user(user_id):
		return Account.query.get(user_id)
Esempio n. 19
0
def init_login_manager(app):
    login_manager = LoginManager()
    login_manager.login_view = "auth.login"
    login_manager.setup_app(app)

    @login_manager.user_loader
    def load_user(userid):
        return User(userid)
Esempio n. 20
0
def init_login(app):
    login_manager = LoginManager()
    login_manager.init_app(app)

    @login_manager.user_loader
    def load_user(user_id):
        from app.models import User
        return User.query.filter_by(id=user_id).first()
Esempio n. 21
0
	def init_login(self, app):
		login_manager = LoginManager(app)
		login_manager.login_view = self.login_endpoint

		# User Loader
		@login_manager.user_loader
		def load_user(id):
			return self.get_user(id)
Esempio n. 22
0
def configure_identity(app):
    login_manager = LoginManager()
    login_manager.init_app(app)
    login_manager.login_view = "account.login"

    @login_manager.user_loader
    def load_user(userid):
        return User.get_by_id(int(userid))
Esempio n. 23
0
    def init_app(self, app, datastore):
        """Initializes the Flask-Security extension for the specified
        application and datastore implentation.

        :param app: The application.
        :param datastore: An instance of a user datastore.
        """
        if app is None or datastore is None:
            return

        # TODO: change blueprint name
        blueprint = Blueprint('auth', __name__)

        configured = {}

        for key, value in default_config.items():
            configured[key] = app.config.get(key, value)

        app.config.update(configured)
        config = app.config

        # setup the login manager extension
        login_manager = LoginManager()
        login_manager.anonymous_user = AnonymousUser
        login_manager.login_view = config[LOGIN_VIEW_KEY]
        login_manager.setup_app(app)
        app.login_manager = login_manager

        Provider = get_class_from_config(AUTH_PROVIDER_KEY, config)
        Form = get_class_from_config(LOGIN_FORM_KEY, config)
        pw_hash = config[PASSWORD_HASH_KEY]

        app.pwd_context = CryptContext(schemes=[pw_hash], default=pw_hash)
        app.auth_provider = Provider(Form)
        app.principal = Principal(app)

        from flask.ext import security as s
        s.User, s.Role = datastore.get_models()

        setattr(app, config[USER_DATASTORE_KEY], datastore)

        @identity_loaded.connect_via(app)
        def on_identity_loaded(sender, identity):
            if hasattr(current_user, 'id'):
                identity.provides.add(UserNeed(current_user.id))

            for role in current_user.roles:
                identity.provides.add(RoleNeed(role.name))

            identity.user = current_user

        @login_manager.user_loader
        def load_user(user_id):
            try:
                return datastore.with_id(user_id)
            except Exception, e:
                logger.error('Error getting user: %s' % e)
                return None
Esempio n. 24
0
def configure_login_manager(app):
    login_manager = LoginManager()
    login_manager.init_app(app)

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

    login_manager.login_view = "frontend.signin"
Esempio n. 25
0
def setup_login(app):
    from models import User
    login_manager = LoginManager()
    login_manager.login_view = 'Common.login'
    login_manager.init_app(app)

    @login_manager.user_loader
    def load_user(userid):
        return User.query.get(userid)
Esempio n. 26
0
def init_login(app):
    login_manager = LoginManager()
    login_manager.init_app(app)

    @login_manager.user_loader
    def load_user(userid):
        return User()

    return login_manager
def init_login():
    login_manager = LoginManager()
    login_manager.login_view = "/login/"
    login_manager.init_app(app)

    @login_manager.user_loader
    def load_user(user_id):
        from lightningwolf_smp.models import User
        return db.session.query(User).get(user_id)
Esempio n. 28
0
def configure_extensions(app):
    from flask.ext.login import LoginManager
    login_manager = LoginManager()
    login_manager.init_app(app)

    @login_manager.user_loader
    def load_user(userid):
        from webapp.api import User
        return User(userid)
Esempio n. 29
0
def init_login():
    login_manager = LoginManager()
    login_manager.init_app(app)

    login_manager.login_view = 'login'
    # Create user loader function
    @login_manager.user_loader
    def load_user(user_id):
        return db.session.query(User).get(user_id)
Esempio n. 30
0
 def test_no_user_loader_raises(self):
     login_manager = LoginManager(self.app, add_context_processor=True)
     with self.app.test_request_context():
         session['user_id'] = '2'
         with self.assertRaises(Exception) as cm:
             login_manager.reload_user()
         expected_exception_message = 'No user_loader has been installed'
         self.assertTrue(
             str(cm.exception).startswith(expected_exception_message))
Esempio n. 31
0
    def is_authenticated(self):
        return True

    def is_actice(self):
        return True

    def is_anonymous(self):
        return False

    def get_id(self):
        return "1"


# flask-login
app.secret_key = 's3cr3t'
login_manager = LoginManager()
login_manager.session_protection = 'strong'
login_manager.login_view = 'auth.login'
login_manager.init_app(app)


@login_manager.user_loader
def load_user(user_id):
    user = User()
    return user


auth = Blueprint('auth', __name__)


@auth.route('/login', methods=['GET', 'POST'])
Esempio n. 32
0
import config

app = Flask(__name__)

# TODO: do all of this in config
app.config['SQLALCHEMY_DATABASE_URI'] = config.HIPFLASK_SQLITE_CONN

db = SQLAlchemy(app)

SECRET_KEY = "yeah, not actually a secret"
DEBUG = True

app.config.from_object(__name__)

login_manager = LoginManager()


class TreeNode(object):
    def __init__(self, value=None):
        self.value = value
        self.parent = None
        self.children = OrderedDict()
        #self.children = defaultdict(lambda: None)

    def __iter__(self):
        return self.children.iteritems()

    def __getitem__(self, item):
        return self.children[item]
if config.test:
    from mockdbhelper import MockDBHelper as DBHelper
else:
    from dbhelper import DBHelper

from passwordhelper import PasswordHelper
from bitlyhelper import BitlyHelper
from user import User

from forms import RegistrationForm
from forms import LoginForm
from forms import CreateTableForm

app = Flask(__name__)
app.secret_key = "Gxf613UhGRkzAKd47R5daLrUelnlUL4L6AU4z0uu++TNBpdzhAolufHqPQiiEdn34pbE97bmXbN"
login_manager = LoginManager(app)

DB = DBHelper()
PH = PasswordHelper()
BH = BitlyHelper()


@login_manager.user_loader
def load_user(user_id):
    user_password = DB.get_user(user_id)
    if user_password:
        return User(user_id)


@app.route("/login", methods=["POST"])
def login():
Esempio n. 34
0
from flask import Flask, g
from flask.ext.login import LoginManager

import models

DEBUG = True
PORT = 8000
HOST = '0.0.0.0'

app = Flask(__name__)
app.secret_key = 'auoesh.bouoastuh.43,uoausoehuosth3ououea.auoub!'

login_manager = LoginManager()
login_manager.init_app(app)
login_manager.login_view = 'login'


@login_manager.user_loader
def load_user(userid):
    try:
        return models.User.get(models.User.id == userid)
    except models.DoesNotExist:
        return None


@app.before_request
def before_request():
    """Connect to the database before each request."""
    g.db = models.DATABASE
    g.db.connect()
Esempio n. 35
0
'''
程序包的构造函数
'''
from flask import Flask  #主程序
from flask.ext.bootstrap import Bootstrap  #模板
from flask.ext.mail import Mail  #邮件服务
from flask.ext.moment import Moment  #时间服务
from flask.ext.sqlalchemy import SQLAlchemy  #数据库服务
from flask.ext.pagedown import PageDown  #支持富文本

from config import config  #导入配置
from flask.ext.login import LoginManager  #认证管理

#认证管理对象
login_manager = LoginManager()
login_manager.session_protection = 'strong'  #认证管理的强度
login_manager.login_view = 'auth.login'  #设置登录页面的端点

bootstrap = Bootstrap()
mail = Mail()
moment = Moment()
db = SQLAlchemy()
pagedown = PageDown()


def create_app(config_name):
    app = Flask(__name__)
    app.config.from_object(config[config_name])
    config[config_name].init_app(app)

    bootstrap.init_app(app)
Esempio n. 36
0
from flask_wtf.csrf import CsrfProtect
app = Flask(__name__)
bootstrap = Bootstrap(app)
app.config['SECRET_KEY'] = 'secret!'
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///data.sqlite3'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS']=False
app.config['UPLOAD_FOLDER'] = os.path.join(os.getcwd()+'/uploads/')
app.config['ALLOWED_EXTENSIONS'] = ['txt', 'pdf', 'png', 'jpg', 'jpeg', 'gif']
app.config['WTF_CSRF_ENABLED'] = True

csrf = CsrfProtect()
csrf.init_app(app)


db = SQLAlchemy(app)
login_manager = LoginManager()
login_manager.init_app(app)

login_manager.refresh_view = "/reauthenticate"

login_manager.login_view = '/login'
login_manager.login_message = 'PLease log in to access the page.'

login_manager.refresh_view = '/changepass'
login_manager.needs_refresh_message = "Confirm your account"


class User(UserMixin, db.Model):
    __tablename__ = 'user'
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String, unique=True)
Esempio n. 37
0
# multiprocessing
from multiprocessing import Process

# custom
from Malcom.auxiliary.toolbox import *
from Malcom.model.model import Model as ModelClass
from Malcom.model.user_management import UserManager as UserManagerClass
from Malcom.web.messenger import WebMessenger

ALLOWED_EXTENSIONS = set(['txt', 'csv'])

app = Flask(__name__)
app.secret_key = os.urandom(24)
app.debug = True
lm = LoginManager()

# This enables the server to be ran behind a reverse-proxy
# Make sure you have an nginx configuraiton similar to this

# location = /malcom { rewrite ^ /malcom/; }
# location /malcom { try_files $uri @malcom; }

# # proxy
# location @malcom {
# 	proxy_pass http://127.0.0.1:8080;
# 	proxy_http_version 1.1;
# 	proxy_set_header SCRIPT_NAME /malcom;
# 	proxy_set_header Host $host;
# 	proxy_set_header X-Scheme $scheme;
# 	proxy_set_header Upgrade $http_upgrade;
Esempio n. 38
0
import re

# Create flask app
app = Flask(__name__)
app.config.from_object('config')

# Connect to AWS
emr = emr_connect(app.config['AWS_REGION'])
ec2 = ec2_connect(app.config['AWS_REGION'])
ses = ses_connect('us-east-1')  # only supported region!
s3 = s3_connect(app.config['AWS_REGION'])
bucket = s3.get_bucket(app.config['TEMPORARY_BUCKET'], validate=False)
code_bucket = s3.get_bucket(app.config['CODE_BUCKET'], validate=False)

# Create login manager
login_manager = LoginManager()
login_manager.anonymous_user = AnonymousUser

# Initialize browser id login
browser_id = BrowserID()

# Cron-related constants:
CRON_IDX_MIN = 0
CRON_IDX_HOUR = 1
CRON_IDX_DOM = 2
CRON_IDX_MON = 3
CRON_IDX_DOW = 4
CRON_IDX_CMD = 5


def connect_db(db_url=None):
Esempio n. 39
0
from flask.ext.cache import Cache
from flask.ext.debugtoolbar import DebugToolbarExtension
from flask.ext.login import LoginManager
from flask_assets import Environment

from rpivideo.models import User

# Setup flask cache
cache = Cache()

# init flask assets
assets_env = Environment()

debug_toolbar = DebugToolbarExtension()

login_manager = LoginManager()
login_manager.login_view = "main.login"
login_manager.login_message_category = "warning"


@login_manager.user_loader
def load_user(userid):
    return User.query.get(userid)
Esempio n. 40
0
from user import User
from itsdangerous import URLSafeTimedSerializer
from flask.ext.misaka import Misaka
from flask.ext.pagedown import PageDown
from bson.objectid import ObjectId
from flask.ext.paginate import Pagination
from link import Meta
from imgur import Imgur
from werkzeug import secure_filename
import json
import string

# GLOBALS
app = Flask(__name__)
app.config.from_pyfile('root.cfg')
lm = LoginManager()
app.config['ALLOWED_EXTENSIONS'] = set(['png', 'jpg', 'jpeg', 'gif', 'gifv'])
app.config['MAX_CONTENT_LENGTH'] = 10 * 1024 * 1024
lm.init_app(app)
lm.login_view = 'login'
mail = Mail(app)
Misaka(app)
pagedown = PageDown(app)


def allowed_file(filename):
    return '.' in filename and \
           filename.rsplit('.', 1)[1] in app.config['ALLOWED_EXTENSIONS']


@app.route('/login', methods=['GET', 'POST'])
Esempio n. 41
0
from flask.ext.login import LoginManager, UserMixin, login_user, logout_user,\
    current_user
from oauth import OAuthSignIn

app = Flask(__name__)
app.config['SECRET_KEY'] = 'top secret!'
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///db.sqlite'
app.config['OAUTH_CREDENTIALS'] = {
    'facebook': {
        'id': '1443828952597505',
        'secret': '296511ffe34ae6f13ae9b56ec35c4818'
    }
}

db = SQLAlchemy(app)
lm = LoginManager(app)
lm.login_view = 'index'


class User(UserMixin, db.Model):
    __tablename__ = 'users'
    id = db.Column(db.Integer, primary_key=True)
    social_id = db.Column(db.String(64), nullable=False, unique=True)
    nickname = db.Column(db.String(64), nullable=False)
    email = db.Column(db.String(64), nullable=True)


@lm.user_loader
def load_user(id):
    return User.query.get(int(id))
Esempio n. 42
0
    import string
    app.secret_key = ''.join(
        random.SystemRandom().choice(string.ascii_lowercase + string.digits)
        for _ in range(24))

# SetUP the library
API_i18n = AlienvaultMessageHandler
locales_dir = os.path.dirname(os.path.abspath(__file__)) + "/api_i18n/locales/"
(success, msg) = API_i18n.setup("alienvault_api", locales_dir,
                                AlienvaultApps.API, i18nmsgs.api_messages)
if not success:
    app.logger.warning("Error handler can't be installed: %s" % (msg))

db = SQLAlchemy(app, session_options={'autocommit': True})

login_manager = LoginManager(app)
principals = Principal(app)

# Use nice error handlers for all common HTTP codes.
use_pretty_default_error_handlers(app)

from celerymethods.celery_manager import CeleryManager

cm = CeleryManager()
cm.start()

try:
    from celerymethods.tasks.tasks import Scheduler
    scheduler = Scheduler()
    scheduler.restore_tasks_to_db()
except Exception as e:
Esempio n. 43
0
# User authentication specific code
from flask import Blueprint, render_template, flash, request, redirect, \
    url_for
from flask_wtf import Form
from wtforms import PasswordField, SubmitField
from flask.ext.login import LoginManager, login_user, UserMixin, logout_user
from wtforms.validators import DataRequired, AnyOf
from utils import get_env

auth_key = get_env('FLASK_APP_PASSWORD') or 'topsecret'
auth_keys = [auth_key]  # TODO ugly quick workaround

mod = Blueprint('authentication', __name__)

login_manager = LoginManager()
login_manager.login_view = "authentication.login"


class User(UserMixin):
    # http://gouthamanbalaraman.com/blog/minimal-flask-login-example.html
    # https://flask-login.readthedocs.org/en/latest/#your-user-class

    # TODO
    # id = db.Column(db.Integer, primary_key=True)
    # username = db.Column(db.String(80), unique=True)
    # email = db.Column(db.String(120), unique=True)

    def __init__(self):
        self.id = "no-one"

    @classmethod
Esempio n. 44
0
def create_app():

    app = flask.Flask(__name__)
    app.debug = True

    # Configurations set above in the ConfigClass ...
    app.config.from_object(__name__ + '.ConfigClass')

    #app.logger.debug(ssl.PROTOCOL_TLSv1)

    # Initialize Flask extensions
    db = SQLAlchemy(app)  # Initialize Flask-SQLAlchemy
    mail = Mail(app)  # Initialize Flask-Mail ...
    bcrypt = Bcrypt(app)  # Inifialize Bcrypt ...

    # Define the User data model. Make sure to add flask.ext.user UserMixin !!!
    class User(db.Model, UserMixin):

        id = db.Column(db.Integer, primary_key=True)

        password = db.Column(db.String(255), nullable=False, server_default='')
        #reset_password_token = db.Column(db.String(100), nullable=False, server_default='')
        authenticate = db.Column(db.Boolean)

        email = db.Column(db.String(255), nullable=False, unique=True)
        confirmed_at = db.Column(db.DateTime())

        is_enabled = db.Column(db.Boolean(), nullable=False, default=False)
        active = db.Column('is_active',
                           db.Boolean(),
                           nullable=False,
                           server_default='0')
        registered_on = db.Column('registered_on', db.DateTime)

        chrome_hash = db.Column(db.String(500))
        secure_token = db.Column(db.String(500))

        def hash_password(self, password):
            self.password = bcrypt.generate_password_hash(password)

        def verify_password(self, password):
            return bcrypt.check_password_hash(self.password, password)

        def activate(self):
            self.authenticate = True

        def is_authenticated(self):
            return True

        def is_active(self):
            return True

        def is_anonymous(self):
            return False

        def get_id(self):
            return unicode(self.id)

        def set_chrome_hash(self):
            self.chrome_hash = str(hashlib.sha224(self.email).hexdigest())

        def set_secure_token(self):
            secure_token = make_secure_token(self.email)

    class Path(db.Model):

        __tablename__ = 'paths'

        id = db.Column(db.Integer, primary_key=True)
        path = db.Column(db.String(50), nullable=False, unique=True)
        url = db.Column(db.String(250), nullable=False)
        creator_id = db.Column(db.Integer, nullable=True)
        clicks = db.Column(db.Integer, default=0)
        note = db.Column(db.String(300), default="No note.")
        timestamp = db.Column(db.DateTime)

    ### INITIALIZE THE DB, USER MODEL, LOGIN MANAGER, ETC. ... ###

    db.create_all()  # Create all database tables if they don't exist ...
    db_adapter = SQLAlchemyAdapter(db, User)  # Register the User model
    user_manager = UserManager(db_adapter, app)  # Initialize Flask-User
    login_manager = LoginManager()  # Initialize the Login manager? ...
    login_manager.init_app(
        app)  # this needs a secret key, set above in the Config class

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

    ######################################################################
    #                                                                    #
    #                       CONFIRMATION EMAILS                          #
    #                                                                    #
    ######################################################################

    def get_serializer(secret_key=None):
        app.logger.debug("in get_serializer")
        if secret_key is None:
            secret_key = app.secret_key
        return URLSafeSerializer(secret_key)

    @app.route('/users/activate/<payload>')
    def activate_user(payload):
        app.logger.debug("in activate_user")
        s = get_serializer()
        try:
            user_id = s.loads(payload)
        except BadSignature:
            abort(404)

        user = User.query.get_or_404(user_id)
        user.authenticate = True
        db.session.commit()

        flash('User activated')
        return flask.redirect(home_url)

    def get_activation_link(user):
        app.logger.debug("in get_activation_link")
        s = get_serializer()
        payload = s.dumps(user.id)

        return url_for('activate_user', payload=payload)

    def send_confirmation_email(user):
        link = get_activation_link(user)
        msg = Message("Hello", sender="*****@*****.**")
        msg.add_recipient(user.email)
        msg.body = "people.ischool.berkeley.edu/~brian.carlo/server" + link
        mail.send(msg)

    ######################################################################
    #                                                                    #
    #                       REGISTRATION AND LOGIN                       #
    #                                                                    #
    ######################################################################

    @app.route('/login.html', methods=["GET", "POST"])
    def login():
        if request.method == 'GET':
            return render_template('login.html')
        email = request.form['email']
        password = request.form['password']

        registered_user = User.query.filter_by(email=email).first()

        if registered_user.verify_password(password):
            login_user(registered_user)
            flash('Logged in successfully')
            return flask.redirect(dashboard_url)
        else:
            flash('Username or Password is invalid', 'error')
            return render_template('login.html')

    @app.route('/register.html', methods=['GET', 'POST'])
    def register():
        if request.method == 'GET':
            return render_template('register.html')
        try:
            user = User(email=request.form['email'])
            user.hash_password(request.form['password'])
            db.session.add(user)
            db.session.commit()
            registered_user = User.query.filter_by(email=user.email).first()
            send_confirmation_email(registered_user)
            registered_user.set_chrome_hash()

            app.logger.debug(registered_user.chrome_hash)
            db.session.commit()

            response = make_response(flask.redirect(home_url))
            response.set_cookie('chrome_id',
                                value=registered_user.chrome_hash,
                                max_age=2592000)
            return response
        except:
            flash(
                "That e-mail address is already Nerping for real. Maybe Nerp a different e-mail?"
            )
            return render_template('register.html')

    ######################################################################
    #                                                                    #
    #                           POSTING PATHS!                           #
    #                                                                    #
    ######################################################################

    @app.before_request
    def validate():  # runs before any app.route()
        """ Helper validates URLs and handles errors for CHROME_PUT(), SHORTS_PUT(). """
        if request.path == '/shorts':  # if the server request is to '/shorts' ...
            shortpath = str(
                request.form.get('shortpath')).strip()  # grab the shortpath
            if shortpath == "":
                pass  # if there's no path, no worries
            else:
                if Path.query.filter_by(path=shortpath).first():
                    app.logger.debug("made it here")
                    flash("already taken!")

            inputURL = str(
                request.form.get('url')).lower().strip()  # grab the URL
            if inputURL == None or inputURL == "":  # if it's not there ...
                abort(412)  # throw the 412

    def insert_path_for_user_or_not(path, inputURL):
        """ HELPER FOR CHROME_PUT(), SHORTS_PUT() """
        try:
            new_path = Path(path=path,
                            url=inputURL,
                            creator_id=current_user.id,
                            timestamp=datetime.utcnow())
            app.logger.debug("UID!")
        except:
            app.logger.debug("NOID!")
            new_path = Path(path=path,
                            url=inputURL,
                            creator_id=None,
                            timestamp=datetime.utcnow())
        db.session.add(new_path)
        db.session.commit()

    def make_random_path():
        """ HELPER FOR CHROME_PUT(), SHORTS_PUT() """
        myPath = ""
        for i in range(7):
            myPath = myPath + chr(random.choice(possible))
        return myPath

    def format_url(inputURL):
        """ HELPER FOR CHROME_PUT(), SHORTS_PUT() """
        parsed = urlparse(inputURL)
        if parsed.scheme == "":
            inputURL = "http://" + inputURL

        h = httplib2.Http()
        try:
            response = h.request(inputURL, 'HEAD')
            inputURL = response[0]['content-location']
            return inputURL
        except:
            return False

    def insert_note(path):
        added_path = Path.query.filter_by(path=path).first()
        added_path.note = str(request.form.get('note', ''))

    @app.route('/chrome', methods=['PUT', 'POST'])
    def chrome_put():

        if 'chrome_id' not in request.cookies:
            user_id = 0
        else:
            chrome_hash = request.cookies.get('chrome_id')
            user = User.query.filter_by(chrome_hash=chrome_hash).first()
            user_id = user.id

        inputURL = str(request.form.get('url', '')).lower()

        inputURL = format_url(inputURL)
        if not inputURL:
            response = make_response("Broken URL. Try another")
            return response

        shortpath = str(request.form.get('shortpath', ''))

        if not shortpath:
            myPath = make_random_path()
            while Path.query.filter_by(path=myPath).first():
                myPath = make_random_path()
            insert_path_for_user_or_not(myPath, inputURL)
            insert_note(myPath)
        else:
            insert_path_for_user_or_not(shortpath, inputURL)
            insert_note(shortpath)
        return flask.redirect(
            'http://people.ischool.berkeley.edu/~brian.carlo/server/chrome.html'
        )

    @app.route('/shorts', methods=['PUT', 'POST'])
    def shorts_put():
        try:
            inputURL = str(request.form.get('url', '')).lower()
            inputURL = format_url(inputURL)
            if not inputURL:
                response = make_response("Broken URL. Try another")
                return response

            shortpath = str(request.form.get('shortpath', ''))

            app.logger.debug(inputURL + "," + shortpath)

            if not shortpath:
                myPath = make_random_path()
                while Path.query.filter_by(path=myPath).first():
                    myPath = make_random_path()
                insert_path_for_user_or_not(myPath, inputURL)
                path = myPath
            else:
                insert_path_for_user_or_not(shortpath, inputURL)
                path = shortpath
            try:
                if current_user.id:
                    return flask.redirect(dashboard_url)
            except:
                flash("nerp.me/" + path)
                return render_template('promo.html')

        except:
            abort(405)

    @app.route('/delete', methods=['POST', 'PUT'])
    @login_required
    def delete_nerp():
        nerp_id = str(request.form.get('nerp_id',
                                       ''))  # REMEMBER TO CHANGE "NERP-ID"
        death_row_nerp = Path.query.filter_by(id=nerp_id).first()
        db.session.delete(death_row_nerp)
        db.session.commit()

    ######################################################################
    #                                                                    #
    #                           GET METHODS!                             #
    #                                                                    #
    ######################################################################

    @app.route('/shorts/<shortpath>', methods=['GET'])
    def shorts_shortpath(shortpath):
        try:
            path = Path.query.filter_by(path=shortpath).first()
            url = path.url
            path.clicks = path.clicks + 1
            db.session.commit()
            return flask.redirect(url)
        except:
            abort(404)

    @app.route('/chrome.html', methods=['GET'])
    def chrome_dash():
        return render_template('chrome.html')

    @app.route('/home.html', methods=['GET'])
    def root():
        return render_template('promo.html')

    @app.route('/dashboard.html', methods=['GET'])
    @login_required
    def dashboard():
        items = Path.query.filter_by(creator_id=current_user.id).order_by(
            Path.timestamp.desc()).all()
        top_nerps = Path.query.order_by(Path.clicks.desc()).limit(10)
        return render_template('dashboard.html',
                               items=items,
                               top_nerps=top_nerps)

    @app.route('/logout', methods=['GET'])
    def logout():
        logout_user()
        return flask.redirect(home_url)

    ######################################################################
    #                                                                    #
    #                           ERROR HANDLERS!                          #
    #                                                                    #
    ######################################################################

    @app.errorhandler(412)
    def precondition_failed(e):
        flash("put in a url, dumbass")
        try:
            if current_user.is_authenticated:
                return flask.redirect(dashboard_url)
        except:
            return render_template('promo.html')

    @app.errorhandler(404)
    def page_not_found(e):
        return render_template('404.html'), 404

    @app.errorhandler(405)
    def method_not_allowed(e):
        return render_template('promo.html'), 405

    @app.errorhandler(409)
    def conflict(e):
        return render_template(
            'final_temp_3.html',
            code=409,
            message="Short path already exists. Please choose a different path."
        ), 409

    return app
Esempio n. 45
0
def _get_login_manager(app):
    lm = LoginManager()
    lm.anonymous_user = AnonymousUser
    lm.login_view = '%s.login' % cv('BLUEPRINT_NAME', app=app)
    lm.user_loader(_user_loader)
    lm.token_loader(_token_loader)

    if cv('FLASH_MESSAGES', app=app):
        lm.login_message, lm.login_message_category = cv('MSG_LOGIN', app=app)
        lm.needs_refresh_message, lm.needs_refresh_message_category = cv('MSG_REFRESH', app=app)
    else:
        lm.login_message = None
        lm.needs_refresh_message = None

    lm.init_app(app)
    return lm
Esempio n. 46
0
from flask import Flask
from flask.ext.bootstrap import Bootstrap
from flask.ext.mail import Mail
from flask.ext.moment import Moment
from flask.ext.sqlalchemy import SQLAlchemy
from config import config, Config
from flask.ext.login import LoginManager
from flask.ext.pagedown import PageDown
import flask_whooshalchemyplus

bootstrap = Bootstrap()
mail = Mail()
moment = Moment()
db = SQLAlchemy()
login_manager = LoginManager()
login_manager.session_protection = 'strong'
login_manager.login_view = 'auth.login'
login_manager.login_message = '请先登录!'
pagedown = PageDown()


def create_app(config_name):
    app = Flask(__name__, static_url_path='/static')
    app.config.from_object(config[config_name])
    config[config_name].init_app(app)

    bootstrap.init_app(app)
    mail.init_app(app)
    moment.init_app(app)
    db.init_app(app)
    login_manager.init_app(app)
Esempio n. 47
0
from flask.ext.sqlalchemy import SQLAlchemy
from flask import request, session, g, redirect, url_for, \
    abort, render_template, flash
from flask.ext.login import LoginManager, login_user, logout_user, \
    current_user, login_required

from flask.ext.babelex import gettext, ngettext, Babel
_ = gettext

app = Flask(__name__, static_folder="static")
app.config.from_object('config')
babel = Babel(app)

from db_model.base import init_engine, clear_db, init_db, db_session
from app.db_model.user import User
login_manager = LoginManager()
login_manager.login_view = '/login'
login_manager.init_app(app)
login_manager.login_message = ""


@login_manager.user_loader
def load_user(user_id):
    return User.query.get(user_id)


@app.teardown_request
def remove_db_session(exception=None):
    db_session.remove()

Esempio n. 48
0
}, {
    'id': '2',
    'email': '*****@*****.**',
    'password': '******'
}]

app = Flask('watermark')
app.secret_key = 'LearnFlaskTheHardWay2017'

upload_dir = os.path.join(app.instance_path, 'upload')

if not os.path.exists(upload_dir):
    os.makedirs(upload_dir, mode=0o755)

# Add LoginManager
login_manager = LoginManager()
login_manager.session_protection = 'AdminPassword4Me'
login_manager.login_view = 'signin'
login_manager.login_message = 'Unauthorized User'
login_manager.login_message_category = "info"
login_manager.init_app(app)


def query_user(email):
    for user in users:
        if user['email'] == email:
            return user


@login_manager.user_loader
def load_user(user_id):
Esempio n. 49
0
class Server():
    def __init__(self,
                 configfile=None,
                 basedir=None,
                 host="0.0.0.0",
                 port=5000,
                 debug=False,
                 allowRoot=False,
                 logConf=None):
        self._configfile = configfile
        self._basedir = basedir
        self._host = host
        self._port = port
        self._debug = debug
        self._allowRoot = allowRoot
        self._logConf = logConf
        self._server = None

    def run(self):
        if not self._allowRoot:
            self._checkForRoot()

        global printer
        global printerProfileManager
        global fileManager
        global slicingManager
        global analysisQueue
        global userManager
        global eventManager
        global loginManager
        global pluginManager
        global appSessionManager
        global debug

        from tornado.ioloop import IOLoop
        from tornado.web import Application

        import sys

        debug = self._debug

        # first initialize the settings singleton and make sure it uses given configfile and basedir if available
        settings(init=True, basedir=self._basedir, configfile=self._configfile)

        # then initialize logging
        self._initLogging(self._debug, self._logConf)
        logger = logging.getLogger(__name__)

        def exception_logger(exc_type, exc_value, exc_tb):
            logger.error("Uncaught exception",
                         exc_info=(exc_type, exc_value, exc_tb))

        sys.excepthook = exception_logger
        logger.info("Starting OctoPrint %s" % DISPLAY_VERSION)

        # then initialize the plugin manager
        pluginManager = octoprint.plugin.plugin_manager(init=True)

        printerProfileManager = PrinterProfileManager()
        eventManager = events.eventManager()
        analysisQueue = octoprint.filemanager.analysis.AnalysisQueue()
        slicingManager = octoprint.slicing.SlicingManager(
            settings().getBaseFolder("slicingProfiles"), printerProfileManager)
        storage_managers = dict()
        storage_managers[
            octoprint.filemanager.FileDestinations.
            LOCAL] = octoprint.filemanager.storage.LocalFileStorage(
                settings().getBaseFolder("uploads"))
        fileManager = octoprint.filemanager.FileManager(
            analysisQueue,
            slicingManager,
            printerProfileManager,
            initial_storage_managers=storage_managers)
        printer = Printer(fileManager, analysisQueue, printerProfileManager)
        appSessionManager = util.flask.AppSessionManager()

        def octoprint_plugin_inject_factory(name, implementation):
            if not isinstance(implementation,
                              octoprint.plugin.OctoPrintPlugin):
                return None
            return dict(plugin_manager=pluginManager,
                        printer_profile_manager=printerProfileManager,
                        event_bus=eventManager,
                        analysis_queue=analysisQueue,
                        slicing_manager=slicingManager,
                        file_manager=fileManager,
                        printer=printer,
                        app_session_manager=appSessionManager)

        def settings_plugin_inject_factory(name, implementation):
            if not isinstance(implementation, octoprint.plugin.SettingsPlugin):
                return None
            default_settings = implementation.get_settings_defaults()
            get_preprocessors, set_preprocessors = implementation.get_settings_preprocessors(
            )
            plugin_settings = octoprint.plugin.plugin_settings(
                name,
                defaults=default_settings,
                get_preprocessors=get_preprocessors,
                set_preprocessors=set_preprocessors)
            return dict(settings=plugin_settings)

        pluginManager.initialize_implementations(additional_inject_factories=[
            octoprint_plugin_inject_factory, settings_plugin_inject_factory
        ])
        pluginManager.log_all_plugins()
        slicingManager.initialize()

        # configure additional template folders for jinja2
        template_plugins = pluginManager.get_implementations(
            octoprint.plugin.TemplatePlugin)
        additional_template_folders = []
        for plugin in template_plugins:
            folder = plugin.get_template_folder()
            if folder is not None:
                additional_template_folders.append(
                    plugin.get_template_folder())

        import jinja2
        jinja_loader = jinja2.ChoiceLoader([
            app.jinja_loader,
            jinja2.FileSystemLoader(additional_template_folders)
        ])
        app.jinja_loader = jinja_loader
        del jinja2
        app.jinja_env.add_extension("jinja2.ext.do")

        # configure timelapse
        octoprint.timelapse.configureTimelapse()

        # setup command triggers
        events.CommandTrigger(printer)
        if self._debug:
            events.DebugEventListener()

        if settings().getBoolean(["accessControl", "enabled"]):
            userManagerName = settings().get(["accessControl", "userManager"])
            try:
                clazz = octoprint.util.get_class(userManagerName)
                userManager = clazz()
            except AttributeError, e:
                logger.exception(
                    "Could not instantiate user manager %s, will run with accessControl disabled!"
                    % userManagerName)

        app.wsgi_app = util.ReverseProxied(
            app.wsgi_app,
            settings().get(["server", "reverseProxy", "prefixHeader"]),
            settings().get(["server", "reverseProxy", "schemeHeader"]),
            settings().get(["server", "reverseProxy", "hostHeader"]),
            settings().get(["server", "reverseProxy", "prefixFallback"]),
            settings().get(["server", "reverseProxy", "schemeFallback"]),
            settings().get(["server", "reverseProxy", "hostFallback"]))

        secret_key = settings().get(["server", "secretKey"])
        if not secret_key:
            import string
            from random import choice
            chars = string.ascii_lowercase + string.ascii_uppercase + string.digits
            secret_key = "".join(choice(chars) for _ in xrange(32))
            settings().set(["server", "secretKey"], secret_key)
            settings().save()
        app.secret_key = secret_key
        loginManager = LoginManager()
        loginManager.session_protection = "strong"
        loginManager.user_callback = load_user
        if userManager is None:
            loginManager.anonymous_user = users.DummyUser
            principals.identity_loaders.appendleft(users.dummy_identity_loader)
        loginManager.init_app(app)

        if self._host is None:
            self._host = settings().get(["server", "host"])
        if self._port is None:
            self._port = settings().getInt(["server", "port"])

        app.debug = self._debug

        from octoprint.server.api import api
        from octoprint.server.apps import apps

        # register API blueprint
        app.register_blueprint(api, url_prefix="/api")
        app.register_blueprint(apps, url_prefix="/apps")

        # also register any blueprints defined in BlueprintPlugins
        blueprint_plugins = octoprint.plugin.plugin_manager(
        ).get_implementations(octoprint.plugin.BlueprintPlugin)
        for plugin in blueprint_plugins:
            name = plugin._identifier
            blueprint = plugin.get_blueprint()
            if blueprint is None:
                continue

            if plugin.is_blueprint_protected():
                from octoprint.server.util import apiKeyRequestHandler, corsResponseHandler
                blueprint.before_request(apiKeyRequestHandler)
                blueprint.after_request(corsResponseHandler)

            url_prefix = "/plugin/{name}".format(name=name)
            app.register_blueprint(blueprint, url_prefix=url_prefix)
            logger.debug(
                "Registered API of plugin {name} under URL prefix {url_prefix}"
                .format(name=name, url_prefix=url_prefix))

        ## Tornado initialization starts here

        ioloop = IOLoop()
        ioloop.install()

        self._router = SockJSRouter(self._createSocketConnection, "/sockjs")

        upload_suffixes = dict(
            name=settings().get(["server", "uploads", "nameSuffix"]),
            path=settings().get(["server", "uploads", "pathSuffix"]))
        self._tornado_app = Application(
            self._router.urls +
            [(r"/downloads/timelapse/([^/]*\.mpg)",
              util.tornado.LargeResponseHandler,
              dict(path=settings().getBaseFolder("timelapse"),
                   as_attachment=True)),
             (r"/downloads/files/local/([^/]*\.(gco|gcode|g|stl))",
              util.tornado.LargeResponseHandler,
              dict(path=settings().getBaseFolder("uploads"),
                   as_attachment=True)),
             (r"/downloads/logs/([^/]*)", util.tornado.LargeResponseHandler,
              dict(path=settings().getBaseFolder("logs"),
                   as_attachment=True,
                   access_validation=util.tornado.access_validation_factory(
                       app, loginManager, util.flask.admin_validator))),
             (r"/downloads/camera/current", util.tornado.UrlForwardHandler,
              dict(url=settings().get(["webcam", "snapshot"]),
                   as_attachment=True,
                   access_validation=util.tornado.access_validation_factory(
                       app, loginManager, util.flask.user_validator))),
             (r".*", util.tornado.UploadStorageFallbackHandler,
              dict(fallback=util.tornado.WsgiInputContainer(app.wsgi_app),
                   file_prefix="octoprint-file-upload-",
                   file_suffix=".tmp",
                   suffixes=upload_suffixes))])
        max_body_sizes = [("POST", r"/api/files/([^/]*)",
                           settings().getInt(["server", "uploads",
                                              "maxSize"]))]
        self._server = util.tornado.CustomHTTPServer(
            self._tornado_app,
            max_body_sizes=max_body_sizes,
            default_max_body_size=settings().getInt(["server", "maxSize"]))
        self._server.listen(self._port, address=self._host)

        eventManager.fire(events.Events.STARTUP)
        if settings().getBoolean(["serial", "autoconnect"]):
            (port, baudrate) = settings().get(
                ["serial", "port"]), settings().getInt(["serial", "baudrate"])
            printer_profile = printerProfileManager.get_default()
            connectionOptions = get_connection_options()
            if port in connectionOptions["ports"]:
                printer.connect(port=port,
                                baudrate=baudrate,
                                profile=printer_profile["id"]
                                if "id" in printer_profile else "_default")

        # start up watchdogs
        observer = Observer()
        observer.schedule(
            util.watchdog.GcodeWatchdogHandler(fileManager, printer),
            settings().getBaseFolder("watched"))
        observer.start()

        # run our startup plugins
        octoprint.plugin.call_plugin(octoprint.plugin.StartupPlugin,
                                     "on_startup",
                                     args=(self._host, self._port))

        # prepare our after startup function
        def on_after_startup():
            logger.info("Listening on http://%s:%d" % (self._host, self._port))

            # now this is somewhat ugly, but the issue is the following: startup plugins might want to do things for
            # which they need the server to be already alive (e.g. for being able to resolve urls, such as favicons
            # or service xmls or the like). While they are working though the ioloop would block. Therefore we'll
            # create a single use thread in which to perform our after-startup-tasks, start that and hand back
            # control to the ioloop
            def work():
                octoprint.plugin.call_plugin(octoprint.plugin.StartupPlugin,
                                             "on_after_startup")

            import threading
            threading.Thread(target=work).start()

        ioloop.add_callback(on_after_startup)

        # prepare our shutdown function
        def on_shutdown():
            logger.info("Goodbye!")
            observer.stop()
            observer.join()
            octoprint.plugin.call_plugin(octoprint.plugin.ShutdownPlugin,
                                         "on_shutdown")

        atexit.register(on_shutdown)

        try:
            ioloop.start()
        except KeyboardInterrupt:
            pass
        except:
            logger.fatal(
                "Now that is embarrassing... Something really really went wrong here. Please report this including the stacktrace below in OctoPrint's bugtracker. Thanks!"
            )
            logger.exception("Stacktrace follows:")
Esempio n. 50
0
        return self.active
    def get_permission(self):
        return self.permission
    def get_name(self):
        return self.name


class Anonymous(AnonymousUser):
    name = u"Anonymous"

USERS = {}
permission=False

app.config.from_object(__name__)

login_manager = LoginManager()

login_manager.anonymous_user = Anonymous
login_manager.login_view = "login"
login_manager.login_message = u"Please log in to access this page."
login_manager.refresh_view = "reauth"

def _id():
    nb=[x[u"id"] for x in pymongo.MongoClient().site.users.find()]
    g_id=0;
    for x in nb :
        idd=int(x) 
        if idd>g_id:
            g_id=idd
    return g_id
def config_web(args):
    from flask import Flask, request, json
    from flask.ext.login import LoginManager
    from flask.ext.oauth import (
        OAuth, OAuthRemoteApp, OAuthException, get_etree
    )
    from werkzeug import url_decode, parse_options_header
    import flask.ext.oauth as nasty_patch_to_oauth

    global app
    app = Flask('wikimetrics')
    # note absolute_path does not change on the life of the application
    app.absolute_path_to_app_root = get_absolute_path()
    # TODO do we need this config to be created like an object instead of a dictionary?
    web_config = create_object_from_text_config_file(args.web_config)
    # if args.override_config:
    # override_config = create_object_from_text_config_file(args.override_config)
    # TODO override one obj with other, can we use dict?

    app.config.from_object(web_config)

    version, latest = get_wikimetrics_version()
    app.config['WIKIMETRICS_LATEST'] = latest
    app.config['WIKIMETRICS_VERSION'] = version
    
    # configure logging
    if not app.config['DEBUG']:
        import logging
        import sys
        app.logger.addHandler(logging.StreamHandler(stream=sys.stderr))
    
    global login_manager
    login_manager = LoginManager()
    login_manager.init_app(app)

    # TODO, this does not need to be a
    # global, could be stored in flask application context
    global google
    oauth = OAuth()
    google = oauth.remote_app(
        'google',
        base_url=app.config['GOOGLE_BASE_URL'],
        authorize_url=app.config['GOOGLE_AUTH_URI'],
        request_token_url=None,
        request_token_params={
            'scope': app.config['GOOGLE_AUTH_SCOPE'],
            'response_type': 'code',
        },
        access_token_url=app.config['GOOGLE_TOKEN_URI'],
        access_token_method='POST',
        access_token_params={
            'grant_type':
            'authorization_code'
        },
        consumer_key=app.config['GOOGLE_CLIENT_ID'],
        consumer_secret=app.config['GOOGLE_CLIENT_SECRET'],
    )

    global mw_oauth_token
    mw_oauth_token = ConsumerToken(
        app.config['META_MW_CONSUMER_KEY'],
        app.config['META_MW_CLIENT_SECRET'],
    )
Esempio n. 52
0
from flask.ext.script import Manager
from flask.ext.migrate import Migrate, MigrateCommand

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

try:
    app.config.from_envvar('LENSING_SETTINGS')
except RuntimeError:
    # This happens when the environment variable is not set.
    # We can safely ignore this because we usually won't use this (unless we
    # don't want to use local_config.py in a container).
    pass

db = SQLAlchemy(app)
migrate = Migrate(app, db)

manager = Manager(app)
manager.add_command('db', MigrateCommand)

lm = LoginManager()
lm.init_app(app)

# Don't leave empty lines where the blocks were.
# This allows us to have if statements within multiline Javascript strings,
# which, although a bad idea, might sometimes be necessary.
app.jinja_env.trim_blocks = True
app.jinja_env.lstrip_blocks = True

from app import views, models, forms
Esempio n. 53
0
app.config['DEBUG_TB_PROFILER_ENABLED'] = False
app.config['DEBUG_TB_INTERCEPT_REDIRECTS'] = False

toolbar = DebugToolbarExtension(app)

# Setup the password crypting
from flask.ext.bcrypt import Bcrypt

bcrypt = Bcrypt(app)

# Import the views
from app.views import main, user, error

app.register_blueprint(user.userbp)

# Setup the user login process
from flask.ext.login import LoginManager
from app.models import User

login_manager = LoginManager()
login_manager.init_app(app)
login_manager.login_view = 'userbp.signin'


@login_manager.user_loader
def load_user(email):
    return User.query.filter(User.email == email).first()


from app import admin
Esempio n. 54
0
def create_login_manager():
    return LoginManager()
Esempio n. 55
0
from httplib import BAD_REQUEST
from functools import wraps

from urlobject import URLObject
from flask import render_template, current_app, request, redirect
from flask.ext.restful.reqparse import Argument, RequestParser
from flask.ext.login import LoginManager, AnonymousUser, login_user, user_unauthorized, login_url, make_next_param

from utils.sqlalchemyutils import get_or_create

from .models import User
from .app import app

login_manager = LoginManager()
login_manager.setup_app(app)


class JJAnonymousUser(AnonymousUser):
    def __nonzero__(self):
        return False

    def __repr__(self):
        return '%s()' % (self.__class__.__name__, )


login_manager.anonymous_user = JJAnonymousUser


@login_manager.user_loader
def load_user(user_id):
    return User.query.get(int(user_id))
Esempio n. 56
0
# -*- coding: utf-8 -*-

from flask.ext.debugtoolbar import DebugToolbarExtension
from flask.ext.login import LoginManager
from flask.ext.mail import Mail

from database import db
from users.models import User

# Create a tolbar object
debug_toolbar = DebugToolbarExtension()

# Create and setup a logger manager object
login_manager = LoginManager()
login_manager.login_view = 'users.views.login_view'


@login_manager.user_loader
def load_user(userid):
    return db.session.query(User).get(userid)


# Create a flask-mail object
mail = Mail()
Esempio n. 57
0
import conf
from web.lib.utils import redirect_url
from web import utils, notifications, export
from web.lib.view_utils import etag_match
from web.models import User, Article, Role
from web.forms import SignupForm, SigninForm

from web.controllers import UserController, FeedController, \
                            ArticleController, CategoryController

Principal(app)
# Create a permission with a single Need, in this case a RoleNeed.
admin_permission = Permission(RoleNeed('admin'))

login_manager = LoginManager()
login_manager.init_app(app)
login_manager.login_message = gettext('Authentication required.')
login_manager.login_message_category = "info"
login_manager.login_view = 'login'

logger = logging.getLogger(__name__)


#
# Management of the user's session.
#
@identity_loaded.connect_via(app)
def on_identity_loaded(sender, identity):
    # Set the identity user object
    identity.user = current_user
Esempio n. 58
0
    assignment = ListField(DictField())
    edit = StringField()


class Users(Document):
    username = StringField()
    password = StringField()

# user1 = Users(username = "******",
#               password = "******")
# user2 = Users(username = "******",
#               password = "******")
# user2.save()
# user1.save()

login_manager = LoginManager()
app = Flask(__name__)
app.secret_key = 'Why should I tell you my secret key?'

lecturelist = Lecture.objects
for lecture in lecturelist:
    print(lecture.edit)

login_manager.init_app(app)

@login_manager.user_loader
def user_loader(user_id):
    return User()


@app.route('/', methods=['GET', 'POST'])
Esempio n. 59
0
'''
rtp.site.flask_app

author | Immanuel Washington

Functions
---------
monitor_app | creates flask app for monitor db
monitor_lm | creates login manager for monitor db
monitor_db | creates monitor db from sqlalchemy
'''
from flask import Flask
from flask.ext.sqlalchemy import SQLAlchemy
from flask.ext.login import LoginManager

monitor_app = Flask(__name__, static_folder='monitor/static', template_folder='monitor/templates')
monitor_app.config.from_pyfile('monitor/settings.py')

monitor_lm = LoginManager()
monitor_lm.init_app(monitor_app)

monitor_db = SQLAlchemy(monitor_app)
Esempio n. 60
0
# -*- coding: utf-8 -*-

from flask.ext.sqlalchemy import SQLAlchemy
db = SQLAlchemy()
db_ean = SQLAlchemy()

from flask.ext.mail import Mail
mail = Mail()

from flask.ext.cache import Cache
cache = Cache()

from flask.ext.login import LoginManager
login_manager = LoginManager()

from flask_oauth import OAuth
from webapp.config import DefaultConfig
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=DefaultConfig.FACEBOOK_APP_ID,
#consumer_secret=DefaultConfig.FACEBOOK_APP_SECRET,
#request_token_params={'scope': 'email'}
#)