def setUp(self): app = Flask(__name__) auth = Auth(app) self.app = app auth.hash_algorithm = self.HASH_ALGORITHM user = AuthUser(username='******') self.user = user
def setUp(self): app = Flask(__name__) auth = Auth(app) self.app = app auth.hash_algorithm = self.HASH_ALGORITHM user = AuthUser(username="******") self.user = user
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
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
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
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
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
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
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
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
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)
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:
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!
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(): """
'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
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:
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, ]),
# 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']):
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()