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()
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
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'])
def configure_login(app): lm = LoginManager() lm.setup_app(app) @lm.user_loader def load_user(userid): return UserDAO.get(userid)
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)
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()
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
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
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)
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
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
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
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
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)
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
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
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)
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)
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()
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)
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))
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
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"
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)
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)
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)
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)
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))
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'])
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():
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()
''' 程序包的构造函数 ''' 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)
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)
# 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;
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):
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)
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'])
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))
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:
# 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
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
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
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)
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()
}, { '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):
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:")
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'], )
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
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
def create_login_manager(): return LoginManager()
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))
# -*- 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()
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
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'])
''' 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)
# -*- 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'} #)