Esempio n. 1
0
 def setUp(self):
     app = Flask(__name__)
     auth = Auth(app)
     self.app = app
     auth.hash_algorithm = self.HASH_ALGORITHM
     user = AuthUser(username='******')
     self.user = user
Esempio n. 2
0
 def setUp(self):
     app = Flask(__name__)
     auth = Auth(app)
     self.app = app
     auth.hash_algorithm = self.HASH_ALGORITHM
     user = AuthUser(username="******")
     self.user = user
Esempio n. 3
0
    def setUp(self):
        app = Flask(__name__)
        app.secret_key = 'N4buDSXfaHx2oO8g'
        self.app = app
        auth = Auth(app)

        @login_required
        def needs_login():
            return 'needs_login'

        app.add_url_rule('/needs_login/', 'needs_login', needs_login)

        @permission_required(resource='post', action='view')
        def post_view():
            return 'needs_post_view'

        app.add_url_rule('/post_view/', 'post_view', post_view)

        @app.route('/login_view/')
        def login_view():
            return 'login_view'

        user = AuthUser(username='******')
        user.role = 'testuser'
        testuser_role = Role('testuser', [Permission('post', 'view')])
        auth.load_role = lambda _: testuser_role
        self.user = user
Esempio n. 4
0
    def setUp(self):
        app = Flask(__name__)
        app.secret_key = "N4buDSXfaHx2oO8g"
        self.app = app
        auth = Auth(app)

        @login_required
        def needs_login():
            return "needs_login"

        app.add_url_rule("/needs_login/", "needs_login", needs_login)

        @permission_required(resource="post", action="view")
        def post_view():
            return "needs_post_view"

        app.add_url_rule("/post_view/", "post_view", post_view)

        @app.route("/login_view/")
        def login_view():
            return "login_view"

        user = AuthUser(username="******")
        user.role = "testuser"
        testuser_role = Role("testuser", [Permission("post", "view")])
        auth.load_role = lambda _: testuser_role
        self.user = user
Esempio n. 5
0
def auth_roles(app):
    """
    some very basic roles.
    the "user" role can basically update their own profile
    the "admin" role can add and edit users
    the "root" profile can remove admins
    """
    auth = Auth(app, login_url_name="login")
    auth.user_timeout = app.config["USER_TIMEOUT"]

    # permission = Permission(resource, action)
    update_profile = Permission("update", "profile")
    administer_things = Permission("administer", "things")
    dangerous_things = Permission("dangerous", "things")

    roles = {
        "user": Role("user", [update_profile]),
        "admin": Role("admin", [update_profile, administer_things]),
        "root": Role("root", [update_profile, administer_things, dangerous_things]),
    }

    def load_role(role_name):
        return roles.get(role_name)

    auth.load_role = load_role
    return auth
Esempio n. 6
0
 def setUp(self):
     app = Flask(__name__)
     app.secret_key = 'N4buDSXfaHx2oO8g'
     auth = Auth(app)
     auth.hash_algorithm = hashlib.sha1
     user = AuthUser(username='******')
     with app.test_request_context():
         user.set_and_encrypt_password(self.PASSWORD)
     self.app = app
     self.user = user
Esempio n. 7
0
 def setUp(self):
     app = Flask(__name__)
     app.secret_key = "N4buDSXfaHx2oO8g"
     auth = Auth(app)
     auth.hash_algorithm = hashlib.sha1
     user = AuthUser(username="******")
     with app.test_request_context():
         user.set_and_encrypt_password(self.PASSWORD)
     self.app = app
     self.user = user
Esempio n. 8
0
    def setUp(self):
        app = Flask(__name__)
        auth = Auth(app)
        self.app = app

        def load_role(role_name):
            return self.ROLES.get(role_name)

        auth.load_role = load_role
        user = AuthUser(username='******')
        user.role = 'testuser'
        self.user = user
Esempio n. 9
0
    def setUp(self):
        app = Flask(__name__)
        auth = Auth(app)
        self.app = app

        def load_role(role_name):
            return self.ROLES.get(role_name)

        auth.load_role = load_role
        user = AuthUser(username="******")
        user.role = "testuser"
        self.user = user
Esempio n. 10
0
def auth_roles(app):
    auth = Auth(app, login_url_name="login")
    auth.user_timeout = 0

    # permission = Permission(resource, action)
    read_posts = Permission("read", "posts")
    create_subject = Permission("create", "subject")
    administer_things = Permission("administer", "things")

    roles = {
            "user": Role("user", [read_posts]),
            "annointed": Role("annointed", [read_posts, create_subject]),
            "admin": Role("admin",
                [read_posts, create_subject, administer_things])
            }
    
    def load_role(role_name):
        return roles.get(role_name)

    auth.load_role = load_role
    return auth
Esempio n. 11
0
        if request.method == 'POST':
            if request.form.get('message'):
                Note.create(
                    user=auth.get_logged_in_user(),
                    message=request.form['message'],
                )
        next = request.form.get('next') or self.dashboard_url()
        return redirect(next)
    
    def get_context(self):
        return {
            'note_list': Note.select().order_by(('created_date', 'desc')).paginate(1, 3)
        }


auth = Auth(app, db, user_model=User)
admin = Admin(app, auth)


class MessageAdmin(ModelAdmin):
    columns = ('user', 'content', 'pub_date',)

class NoteAdmin(ModelAdmin):
    columns = ('user', 'message', 'created_date',)


auth.register_admin(admin)
admin.register(Message, MessageAdmin)
admin.register(Note, NoteAdmin)
admin.register_panel('Notes', NotePanel)
Esempio n. 12
0
    if os.path.isfile(configfile):
        unsanitizedConfig = configobj.ConfigObj(configfile)
    else:
        sys.exit("Config file {} does not exist.".format(configfile))

    config = json.loads(security.sanitizeString(json.dumps(unsanitizedConfig)),
                        object_pairs_hook=OrderedDict)
    watchfiles = [configfile]
    config = appendDefaultPages(config)
    api.setConfig(config, unsanitizedConfig)
    api.init()
    validateConfigFormat(config)
    domoticz.checkDomoticzStatus(config)
    server_location = config["general_settings"]["server"]["url"]
    flask_server_location = config["general_settings"]["server"]["flask_url"]
    auth = Auth(app, login_url_name='login_form')
    auth.user_timeout = 0

    app.secret_key = config["general_settings"]["server"]["secret_key"]
    app.add_url_rule('/', 'index', index)
    for k, v in config["navbar"]["menu"].iteritems():
        v = strToList(v)
        app.add_url_rule('/' + v[0].lower(),
                         v[0].lower(),
                         generatePage,
                         methods=['GET'])
    app.add_url_rule('/settings', 'settings', generatePage, methods=['GET'])
    app.add_url_rule('/log', 'log', generatePage, methods=['GET'])
    app.add_url_rule('/logout/', 'logout', logout_view, methods=['GET'])
    app.add_url_rule('/api', 'api', api.gateway, methods=['POST'])
    try:
Esempio n. 13
0
from flask import Flask, jsonify, render_template, redirect, request, url_for, g
from dblayer import DBlayer
from flaskext.auth import Auth, AuthUser, login_required, logout, get_current_user_data

db = DBlayer()
app = Flask(__name__, static_folder='web/static', static_url_path='')
app.template_folder = "web"
auth = Auth(app)
app.secret_key = 'N4BUdSXUzHxNoO8g'


@app.before_request
def init_users():
    admin = AuthUser(username='******')
    admin.set_and_encrypt_password('password')
    g.users = {'admin': admin}


@app.route("/")
def feed():
    user = get_current_user_data()
    print user
    return render_template('feed.html', user=user)


@app.route("/login", methods=['GET', 'POST'])
def login():
    if request.method == 'POST':
        username = request.form['username']
        if username in g.users:
            # Authenticate and log in!
Esempio n. 14
0
from flask import Flask, request, g, url_for
from flaskext.auth import Auth, AuthUser, logout, Permission, Role, \
        permission_required

app = Flask(__name__)
auth = Auth(app, login_url_name='index')

user_create = Permission('user', 'create')
user_view = Permission('user', 'view')

roles = {
    'admin': Role('admin', [user_create, user_view]),
    'userview': Role('userview', [user_view]),
}

def load_role(role_name):
    """
    Function that has to be defined to be able to retrieve the actual role
    object from the user.role attribute. In this simple case, we could
    actually assign the role object directly to user.role, in which this
    function would simply be the identity function (lambda x: x). This extra
    step becomes needed however in case the role object is more complex
    and it can't be simply pickled anymore.
    """
    return roles.get(role_name)

auth.load_role = load_role

@app.before_request
def init_users():
    """
Esempio n. 15
0
    'nl': 'Nederlands'
}

from bin.config import Config
settings = Config()

if not settings.local:
    raise Exception('Local settings (%s/settings.py) not found' % app.config['dir_root'])

import findex_gui.controllers.routes.static
import findex_gui.controllers.routes.errors
import findex_gui.controllers.routes.before_request

from flaskext.auth import Auth
import hashlib
auth = Auth(app)
auth.user_timeout = 604800
auth.hash_algorithm = hashlib.sha256

import orm.connect as db_connect
db_types = {k.lower(): v for k, v in vars(db_connect).items() if inspect.isclass(v) and issubclass(v, db_connect.Orm)}

if not app.config['DB_TYPE'] in db_types:
    raise Exception('Unsupported database type \"%s\". Supported: %s' % (
        app.config['DB_TYPE'],
        ','.join([z.lower() for z in db_types.keys() if not z == 'Orm'])))

db = db_types[app.config['DB_TYPE']](app)
db.connect()

from controllers.themes import ThemeController
Esempio n. 16
0
app = Flask(__name__)
app.config.from_pyfile('app.cfg')

# Instantiate DB
db = SQLAlchemy(app)


## Set SQL Alchemy to automatically tear down
@app.teardown_request
def shutdown_session(exception=None):
    db_session.remove()


# Instantiate authentication
auth = Auth(app, login_url_name='login')
User = get_user_class(db.Model)


def index():
    return render_template('index.html')


##login methods


def login():
    if request.method == 'POST':
        username = request.form['username']
        user = User.query.filter(User.username == username).first()
        if user is not None:
Esempio n. 17
0
import datetime
import uuid
from flask import Flask, render_template, request, url_for, g, redirect, session
from flaskext.auth import Auth, AuthUser, login_required, logout, Permission, Role, permission_required
from flask.ext.pymongo import PyMongo
from Cthulog.opression.Opression import opression_api

app = Flask(__name__)
app.config.from_object("config")
app.secret_key = app.config["APP_SECRET_KEY"]

mongo = PyMongo(app, config_prefix="MONGOLAB")
opression_api(app, mongo)

# authentication
auth = Auth(app, login_url_name="login")
# you'll stay logged in unto the heat death of the universe
auth.user_timeout = 0

create_user = Permission("create", "user")
create_section = Permission("create", "section")
create_post = Permission("create", "post")
read_posts = Permission("read", "posts")

roles = {
        "admin": Role("admin", [
            create_user,
            create_section,
            create_post,
            read_posts,
            ]),
Esempio n. 18
0
# stolen from SO
# https://stackoverflow.com/a/16957370


def decimal_default(obj):
    if isinstance(obj, decimal.Decimal):
        return float(obj)
    raise TypeError


login_url_name = 'user_login'

# App Settings
settings = toml.load("settings.toml")
app = Flask(__name__)
auth = Auth(app, login_url_name)
app.secret_key = settings['secret_key']
app.app_state = {
    "authentication_required": True,
}


# this fixes an error in flaskext.auth where it doesn't handle args for redirects.
def _redirect_to_login(*args, **kwargs):
    return redirect(url_for(login_url_name))


auth.not_logged_in_callback = _redirect_to_login

# User Setup
from flask import Flask, request, g, redirect, url_for
app = Flask(__name__)

from flaskext.auth import Auth, AuthUser, login_required, logout
auth = Auth(app, login_url_name='index')


@app.before_request
def init_users():
    """
    Initializing users by hardcoding password. Another use case is to read
    usernames from an external file (like /etc/passwd).
    """
    admin = AuthUser(username='******')
    # Setting and encrypting the hardcoded password.
    admin.set_and_encrypt_password('password', salt='123')
    # Persisting users for this request.
    g.users = {'admin': admin}


@login_required()
def admin():
    return 'Admin! Excellent!'


def index():
    if request.method == 'POST':
        username = request.form['username']
        if username in g.users:
            # Authenticate and log in!
            if g.users[username].authenticate(request.form['password']):
Esempio n. 20
0
    app.config['MONGOALCHEMY_SERVER'] = os.environ['MONGO_SERVER']
else:
    app.config['MONGOALCHEMY_SERVER'] = 'mongo'
if "MONGO_USER" in os.environ:
    app.config['MONGOALCHEMY_USER'] = os.environ['MONGO_USER']
if "MONGO_PASSWORD" in os.environ:
    app.config['MONGOALCHEMY_PASSWORD'] = os.environ['MONGO_PASSWORD']

app.config['MONGOALCHEMY_DATABASE'] = 'cryptowalletsviewer'

try:
    db = MongoAlchemy(app)
except:
    print "DATABASE CONNECTION ERROR"

auth = Auth(app, login_url_name='ulogin')
auth.user_timeout = 0

blockcypher_token = '7dc49cbdcb2245758426621ba54bc345'


class User(db.Document):
    #userId = db.IntField()
    username = db.StringField()
    password = db.StringField()


class Post(db.Document):
    created = db.DateTimeField()
    title = db.StringField()
    comment = db.StringField()