def create_app():
app = Flask(__name__)
app.config['SECRET_KEY'] = '9OLWxND4o83j4K4iuopO'
#app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///db/db.sqlite'
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///db.sqlite'
#with app.app_context():
db.init_app(app)
login_manager = LoginManager()
login_manager.login_view = 'auth.login'
login_manager.init_app(app)
login_manager.anonymous_user = Anonymous
from .models import User
@login_manager.user_loader
def load_user(user_id):
# since the user_id is just the primary key of our user table, use it in the query for the user
return User.query.get(int(user_id))
# blueprint for auth routes in our app
from .auth import auth as auth_blueprint
app.register_blueprint(auth_blueprint)
# blueprint for non-auth parts of app
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
app.app_context().push()
return app
def create_app(config: Config):
app = Flask(__name__, instance_path=config.server.instance_path)
app.config.from_object(config.server)
loglevel = getattr(logging, config.project.loglevel.upper())
app.logger.setLevel(loglevel)
db.init_app(app)
cache.init_app(app, config)
login_manager = LoginManager()
login_manager.init_app(app)
login_manager.login_view = "/login"
login_manager.anonymous_user = AnonymousUser
login_manager.session_protection = "strong"
@login_manager.user_loader
def load_user(userid: str):
return UserService().get(userid)
@app.route("/logout")
@login_required
def logout():
logout_user()
return redirect("/login")
init_dash(app, config)
return app
def test_index_page():
file_path = find_dotenv('.env.test', usecwd=True)
load_dotenv(file_path, override=True)
database_config = DatabaseConfig()
auth_config = AuthConfig()
flask_config = FlaskConfig()
mocked_client = mongomock.MongoClient()
mock_db = mocked_client.get_database(database_config.db_name)
client = AtlasClient(database_config, mocked_client)
login_manager = LoginManager()
login_manager.anonymous_user = TestUser
#Create the new app.
test_app = create_app(client, auth_config, login_manager)
test_app.config.from_object(flask_config)
test_app.config['LOGIN_DISABLED'] = True
mock_item_response = ToDoItem.new_item_as_dict(
"Hello form the integration tests")
mock_db.get_collection("test_collection_name").insert_one(
mock_item_response)
response = test_app.test_client().get("/")
assert 200 == response.status_code
assert "Hello form the integration tests" in response.data.decode()
def test_app():
# construct the new application
try:
file_path = find_dotenv('.env')
load_dotenv(file_path, override=True)
except:
print("Could not find .env")
database_config = DatabaseConfig()
auth_config = AuthConfig()
flask_config = FlaskConfig()
database_config._todo_collection_name = os.environ.get('TEST_COLLECTION')
mongo_client = MongoClient(database_config.db_url)
client = AtlasClient(database_config, mongo_client)
client._collection.delete_many({})
login_manager = LoginManager()
login_manager.anonymous_user = TestUser
application = create_app(client, auth_config, login_manager)
application.config.from_object(flask_config)
application.config['LOGIN_DISABLED'] = True
# start the app in its own thread.
thread = Thread(target=lambda: application.run(use_reloader=False))
thread.daemon = True
thread.start()
yield application
# Tear Down
thread.join(1)
def register_login(app):
login_manager = LoginManager()
login_manager.login_view = "auth.login"
login_manager.session_protection = "strong"
login_manager.login_message = u"这个页面要求登陆，请登陆"
login_manager.anonymous_user = Anonymous
login_manager.init_app(app)
return login_manager
def init_login_manager(app):
login_manager = LoginManager()
login_manager.init_app(app)
login_manager.login_view = 'auth.login'
login_manager.login_message = 'Для доступа к данной странице нужно аутенцифицироваться'
login_manager.login_message_category = 'warning'
login_manager.user_loader(load_user)
login_manager.anonymous_user = Anonymous
def configure_login(app):
login_manager = LoginManager()
login_manager.session_protection = 'strong'
login_manager.login_view = 'user.login'
login_manager.login_message = '请先登录'
login_manager.anonymous_user = Anonymous
login_manager.init_app(app)
@login_manager.user_loader
def load_user(user_id):
return User.query.get(int(user_id))
def setup_login_manager(app):
"""
Configure the LoginManager for the provided app.
"""
login_manager = LoginManager()
login_manager.login_view = 'auth.login_user'
login_manager.login_message = 'Resource access not authorized.'
login_manager.login_message_category = 'error'
login_manager.anonymous_user = AnonymousUser
login_manager.init_app(app)
login_manager.user_loader(load_user)
user_logged_in.connect(on_login, app)
def setup_login_manager(app):
"""
Configure the LoginManager for the provided app.
"""
login_manager = LoginManager()
login_manager.login_view = 'auth.login_user'
login_manager.login_message = 'Resource access not authorized.'
login_manager.login_message_category = 'error'
login_manager.anonymous_user = AnonymousUser
login_manager.init_app(app)
login_manager.user_loader(load_user)
user_logged_in.connect(on_login, app)
def get_login_manager(root: RootConfigDirectoryContext) -> LoginManager: """ Creates a login manager """ login_manager = LoginManager() login_manager.login_view = 'auth.login' login_manager.anonymous_user = AnonymousUserModel @login_manager.user_loader def load_user(uid): return current_app.config['model_factory'].user(str(uid)) return login_manager
def init_login_manager():
login_manager = LoginManager()
login_manager.session_protection = 'strong'
login_manager.login_view = 'auth.login'
from dnsdb_common.dal.models.user import User, AnonymousUser
login_manager.anonymous_user = AnonymousUser
@login_manager.user_loader
def load_user(user_id):
return User.query.get(int(user_id))
return login_manager
def configure_auth(app):
login_manager = LoginManager()
login_manager.init_app(app)
class AnonymousUser(AnonymousUserMixin):
def to_dict(self):
return {"anonynous": True}
login_manager.anonymous_user = AnonymousUser
@login_manager.user_loader
def load_user(user_id):
return auth.load_user(user_id)
def _get_login_manager(app, anonymous_user):
lm = LoginManager()
lm.anonymous_user = anonymous_user or 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
def _get_login_manager(app, anonymous_user):
lm = LoginManager()
lm.anonymous_user = anonymous_user or 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
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):
"""Display login page when user is not authorised."""
if request.is_xhr:
return g._("Authorization failure"), 401
secure_url = url_for(request.endpoint,
_external=True,
_scheme='https',
**request.view_args)
if not urllib.unquote(secure_url).startswith(request.base_url):
return redirect(secure_url)
if current_user.is_guest:
if not session.get('_flashes'):
flash(g._("Please sign in to continue."), 'info')
from invenio_accounts.views.accounts import login
return login(referer=request.url)
else:
from flask import render_template
return render_template("401.html"), 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)
@user_logged_in.connect_via(app)
def _logged_in(sender, user):
"""Update last login date."""
from invenio_accounts.models import User
User.query.filter_by(id=user.get_id()).update(
dict(last_login=datetime.now()))
@_login_manager.user_loader
def _load_user(uid):
"""Do not raise an exception if uid is not valid or missing."""
return UserInfo(int(uid))
return app
def setup_authorization(app, CFG):
# User session management setup
# https://flask-login.readthedocs.io/en/latest
login_manager = LoginManager()
login_manager.init_app(app)
login_manager.anonymous_user = Guest_Info
# Flask-Login helper to retrieve a user from our db
@login_manager.user_loader
def load_user(user_id):
return User_Info.get(user_id)
setup_general_authorization(app, CFG)
if CFG["Server"]["Debug"]:
setup_debug_authorization(app, CFG)
setup_google_authorization(app, CFG)
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):
"""Display login page when user is not authorised."""
if request.is_xhr:
return g._("Authorization failure"), 401
secure_url = url_for(request.endpoint, _external=True, _scheme='https',
**request.view_args)
if not urllib.unquote(secure_url).startswith(request.base_url):
return redirect(secure_url)
if current_user.is_guest:
if not session.get('_flashes'):
flash(g._("Please sign in to continue."), 'info')
from invenio_accounts.views.accounts import login
return login(referer=request.url)
else:
from flask import render_template
return render_template("401.html"), 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)
@user_logged_in.connect_via(app)
def _logged_in(sender, user):
"""Update last login date."""
from invenio_accounts.models import User
User.query.filter_by(id=user.get_id()).update(dict(
last_login=datetime.now()
))
@_login_manager.user_loader
def _load_user(uid):
"""Do not raise an exception if uid is not valid or missing."""
return UserInfo(int(uid))
return app
def _get_login_manager(app, anonymous_user):
lm = LoginManager()
lm.anonymous_user = anonymous_user or AnonymousUser
lm.localize_callback = localize_callback
lm.login_view = "%s.login" % cv("BLUEPRINT_NAME", app=app)
lm.user_loader(_user_loader)
lm.request_loader(_request_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
def init_app(app):
login_manager = LoginManager(app)
login_manager.anonymous_user = models.AnonymousUser
ldap_manager = LDAP3LoginManager(app)
@ldap_manager.save_user
def save_user(dn, username, data, memberships):
user = models.User.get(username)
return user
@login_manager.user_loader
def load_user(id):
return models.User.get(id)
# Set up sanity checks.
from . import sanity
getattr(app, 'sanity_check_modules', []).append(sanity)
def login_manager_factory(state):
"""
Create a login manager accordingly.
"""
login_manager = LoginManager()
login_manager.login_view = 'security.login'
login_manager.login_message_category = "warning"
# Set custom anonymous user to return the user which is running the
# process.
def make_anon_user():
return _AnonymousUserMixin()
login_manager.anonymous_user = make_anon_user
@login_manager.user_loader
def load_user(user_id):
return security_services.get_user(user_id)
return login_manager
def _get_login_manager(
self,
app: FlaskUnchained,
anonymous_user: AnonymousUser,
) -> LoginManager:
"""
Get an initialized instance of Flask Login's
:class:`~flask_login.LoginManager`.
"""
login_manager = LoginManager()
login_manager.anonymous_user = anonymous_user or AnonymousUser
login_manager.localize_callback = _
login_manager.request_loader(self._request_loader)
login_manager.user_loader(
lambda *a, **kw: self.security_utils_service.user_loader(*a, **kw))
login_manager.login_view = 'security_controller.login'
login_manager.login_message = _(
'flask_unchained.bundles.security:error.login_required')
login_manager.login_message_category = 'info'
login_manager.needs_refresh_message = _(
'flask_unchained.bundles.security:error.fresh_login_required')
login_manager.needs_refresh_message_category = 'info'
login_manager.init_app(app)
return login_manager
def register_routes(app):
"""Register app routes."""
def _user_loader(user_id=None, flush_cached=False):
return UserSession(user_id, flush_cached)
login_manager = LoginManager()
login_manager.init_app(app)
login_manager.user_loader(_user_loader)
login_manager.anonymous_user = _user_loader
# Register API routes.
import boac.api.admin_controller
import boac.api.alerts_controller
import boac.api.auth_controller
import boac.api.cohort_controller
import boac.api.config_controller
import boac.api.course_controller
import boac.api.curated_group_controller
import boac.api.notes_controller
import boac.api.search_controller
import boac.api.student_controller
import boac.api.status_controller
import boac.api.user_controller
# Register error handlers.
import boac.api.error_handlers
index_html = open(app.config['INDEX_HTML']).read()
@app.login_manager.unauthorized_handler
def unauthorized_handler():
return jsonify(success=False,
data={'login_required': True},
message='Unauthorized'), 401
# Unmatched API routes return a 404.
@app.route('/api/<path:path>')
def handle_unmatched_api_route(**kwargs):
app.logger.error('The requested resource could not be found.')
raise boac.api.errors.ResourceNotFoundError(
'The requested resource could not be found.')
# Non-API routes are handled by the front end.
@app.route('/', defaults={'path': ''})
@app.route('/<path:path>')
def front_end_route(**kwargs):
vue_base_url = app.config['VUE_LOCALHOST_BASE_URL']
return redirect(vue_base_url +
request.full_path) if vue_base_url else make_response(
index_html)
@app.before_request
def before_request():
session.permanent = True
app.permanent_session_lifetime = datetime.timedelta(
minutes=app.config['INACTIVE_SESSION_LIFETIME'])
session.modified = True
@app.after_request
def after_api_request(response):
if app.config['BOAC_ENV'] == 'development':
# In development the response can be shared with requesting code from any local origin.
response.headers['Access-Control-Allow-Headers'] = 'Content-Type'
response.headers['Access-Control-Allow-Origin'] = app.config[
'VUE_LOCALHOST_BASE_URL']
response.headers['Access-Control-Allow-Credentials'] = 'true'
response.headers[
'Access-Control-Allow-Methods'] = 'GET, POST, OPTIONS, PUT, DELETE'
if request.full_path.startswith('/api'):
log_message = ' '.join([
request.remote_addr,
request.method,
request.full_path,
response.status,
])
if response.status_code >= 500:
app.logger.error(log_message)
elif response.status_code >= 400:
app.logger.warning(log_message)
else:
app.logger.debug(log_message)
return response
from flask import Flask
from flask_sqlalchemy import SQLAlchemy, BaseQuery
from sqlalchemy import create_engine
from sqlalchemy.orm import scoped_session, sessionmaker
from sqlalchemy.ext.declarative import declarative_base
from flask_login import LoginManager
from app.mixins import GuestUserMixin
app = Flask(__name__)
app.config.from_object('config')
engine = create_engine(app.config['SQLALCHEMY_DATABASE_URI'])
db_scoped_session = scoped_session(sessionmaker(bind=engine))
Base = declarative_base()
Base.query = db_scoped_session.query_property(query_cls=BaseQuery)
db = SQLAlchemy(app)
db.session = db_scoped_session
db.Model = Base
login_manager = LoginManager()
login_manager.init_app(app)
login_manager.login_view = 'login'
login_manager.anonymous_user = GuestUserMixin
from app import views, models
def load_user(session_token):
try:
return User.objects.get(session_token=session_token)
except DoesNotExist:
return None
@login_manager.request_loader
def api_auth(request):
try:
return User.objects.get(api_key=request.headers.get('X-Api-Key'))
except DoesNotExist:
return None
login_manager.anonymous_user = auth_module.get_default_user
@frontend.before_request
def frontend_login_required():
if not current_user.is_active and (request.endpoint and
request.endpoint != 'frontend.static'):
return login_manager.unauthorized()
@api.before_request
def api_login_required():
if not current_user.is_active and not request.method == "OPTIONS":
return dumps({"error": "X-Api-Key header missing or invalid"}), 401
logger = make_logger(login_page)
login_manager = LoginManager()
from .pwdmanager import userdb, SeminarsUser, SeminarsAnonymousUser
@login_manager.user_loader
def load_user(uid):
return SeminarsUser(uid)
login_manager.login_view = "user.info"
login_manager.anonymous_user = SeminarsAnonymousUser
def get_username(uid):
"""returns the name of user @uid"""
return SeminarsUser(uid).name
# globally define user properties and username
@app.context_processor
def ctx_proc_userdata():
userdata = {
"user": current_user,
"usertime": datetime.now(tz=current_user.tz),
}
# used to display name of locks
def load_user(session_token):
try:
return User.objects.get(session_token=session_token)
except DoesNotExist:
return None
@login_manager.request_loader
def api_auth(request):
try:
return User.objects.get(api_key=request.headers.get('X-Api-Key'))
except DoesNotExist:
return None
login_manager.anonymous_user = auth_module.get_default_user
@frontend.before_request
def frontend_login_required():
if not current_user.is_active and (request.endpoint and
request.endpoint != 'frontend.static'):
return login_manager.unauthorized()
@api.before_request
def api_login_required():
if not current_user.is_active and not request.method == "OPTIONS":
return dumps({"error": "X-Api-Key header missing or invalid"}), 401
app = Flask(__name__, template_folder='../templates')
app.jinja_env.filters['first_paragraphs'] = first_paragraphs
app.secret_key = _cfg("secret-key")
app.jinja_env.cache = None
app.json_encoder = CustomJSONEncoder
markdown = Markdown(app, safe_mode='remove', extensions=[KerbDown()])
login_manager = LoginManager()
login_manager.init_app(app)
@login_manager.user_loader
def load_user(username: str) -> User:
return User.query.filter(User.username == username).first()
login_manager.anonymous_user = lambda: None
app.register_blueprint(profiles)
app.register_blueprint(accounts)
app.register_blueprint(login_oauth)
app.register_blueprint(anonymous)
app.register_blueprint(blog)
app.register_blueprint(admin)
app.register_blueprint(mods)
app.register_blueprint(lists)
app.register_blueprint(api)
try:
locale.setlocale(locale.LC_ALL, 'en_US')
except:
try:
self.last_seen = datetime.utcnow()
db.session.add(self)
def __repr__(self):
return '<User %r>' % self.username
class AnonymousUser(AnonymousUserMixin):
def can(self, permissions):
return False
def is_administrator(self):
return False
login_manager.anonymous_user = AnonymousUser
# Flask_login requires a callback to load a user using the given identifier
@login_manager.user_loader
def load_user(user_id):
return User.query.get(int(user_id))
class Transaction(db.Model):
__tablename__ = 'transactions'
transaction_id = db.Column(db.Integer,
autoincrement=True,
primary_key=True)
user = db.Column(db.Integer, db.ForeignKey('users.id'))
block = db.Column(db.String(256), unique=True)
from flask_login import AnonymousUserMixin
class BlogAnonymous(AnonymousUserMixin):
def __init__(self):
self.username = '******'
bcrypt = Bcrypt()
oid = OpenID()
login_manager = LoginManager()
login_manager.login_view = "auth.login"
login_manager.session_protection = "strong"
login_manager.login_message = "Please login to access this page"
login_manager.login_message_category = "info"
login_manager.anonymous_user = BlogAnonymous
def create_module(app, **kwargs):
bcrypt.init_app(app)
oid.init_app(app)
login_manager.init_app(app)
twitter_blueprint = make_twitter_blueprint(
api_key=app.config.get("TWITTER_API_KEY"),
api_secret=app.config.get("TWITTER_API_SECRET"),
)
app.register_blueprint(twitter_blueprint, url_prefix="/auth/login")
facebook_blueprint = make_facebook_blueprint(
client_id=app.config.get("FACEBOOK_CLIENT_ID"),
# Flask app init
from flask import Flask
app = Flask(__name__)
app.config.from_object('config')
# TODO SSL Stuff
# import ssl
# ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLSv1_2)
# ssl_context.load_cert_chain('certs/homeberry.pem', 'certs/homeberry.key')
# Flask-SQLAlchemy stuff
from flask_sqlalchemy import SQLAlchemy
db = SQLAlchemy(app)
# Flask-Login stuff
from flask_login import LoginManager
from app.auth.models import HomeberryAnonymousUser
lm = LoginManager()
lm.init_app(app)
lm.anonymous_user = HomeberryAnonymousUser
# PlayerManager and MPDClient
from app.music.players import PlayerManager
pm = PlayerManager()
from app.auth import models, views
from app.music import models, views
LOGIN_MANAGER = LoginManager(app)
LOGIN_MANAGER.login_view = "login"
class Anonymous(AnonymousUserMixin):
"""Class for providing guest sessions in app.
"""
def __init__(self):
self.username = u'GUEST'
self.role = 'user'
self.uid = 2
def __repr__(self):
return unicode(self.username)
LOGIN_MANAGER.anonymous_user = Anonymous
class User(UserMixin):
"""Class which describes User entity."""
def __init__(self, uid, first_name, last_name, email, password, role,
avatar=None):
self.uid = uid
self.first_name = first_name
self.last_name = last_name
self.email = email
self.password = password
self.role = role
self.avatar = avatar
mimetypes.add_type('application/mp4', '.m4a')
mimetypes.add_type('application/mp4', '.m4b')
mimetypes.add_type('application/ogg', '.ogg')
mimetypes.add_type('application/ogg', '.oga')
app = Flask(__name__)
app.config.update(
SESSION_COOKIE_HTTPONLY=True,
SESSION_COOKIE_SAMESITE='Lax',
REMEMBER_COOKIE_SAMESITE='Lax', # will be available in flask-login 0.5.1 earliest
)
lm = LoginManager()
lm.login_view = 'web.login'
lm.anonymous_user = ub.Anonymous
lm.session_protection = 'strong'
ub.init_db(cli.settingspath)
# pylint: disable=no-member
config = config_sql.load_configuration(ub.session)
web_server = WebServer()
babel = Babel()
_BABEL_TRANSLATIONS = set()
log = logger.create()
from . import services
self.is_admin = False
def __bool__(self):
return False
LOGIN_MANAGER = LoginManager(app)
@LOGIN_MANAGER.user_loader
def load_user(user_id):
""" Required by Flask-Login for loading a user by PK. """
return User.query.get(int(user_id))
# Return a "Nobody" instance as the anonymous user here for Flask-Login
LOGIN_MANAGER.anonymous_user = lambda: Nobody()
# -------------------------------------------------------------------------------------------------
class Event(Model):
""" A record for a specific cubing event -- the name of the puzzle, the total number of solves
to be completed by a competitor, and an optional description of the event. """
__tablename__ = 'events'
id = Column(Integer, primary_key=True)
name = Column(String(64), index=True, unique=True)
totalSolves = Column(Integer)
description = Column(String(2048))
eventFormat = Column(Enum("Ao5", "Mo3", "Bo3", "Bo1", name="eventFormat"), default="Ao5")
CompEvents = relationship("CompetitionEvent", backref="Event")
login_manager = LoginManager()
login_manager.init_app(webapp)
# Handle authentication
@login_manager.user_loader
def load_user(user_id):
print "user:", user_id
try:
return User.get(user_id)
except:
return None
login_manager.anonymous_user = User.get_default_user
@api.before_request
@login_required
def api_login_required():
pass
@frontend.before_request
def frontend_login_required():
if not current_user.is_authenticated():
if (request.endpoint and request.endpoint != 'frontend.static'):
return login_manager.unauthorized()
open_id = OpenID(app)
class AdminUser(UserMixin):
id = u'1'
name = 'admin'
active = True
def is_active(self):
return self.active
admin_user = AdminUser()
login_manager = LoginManager()
login_manager.setup_app(app)
login_manager.anonymous_user = AnonymousUser
login_manager.login_view = "login"
login_manager.login_message = u"Please log in to access this page."
login_manager.refresh_view = "reauth"
@login_manager.user_loader
def load_user(id):
if int(id) == 1:
return admin_user
else:
return None
@app.route("/login", methods=["GET", "POST"])
@open_id.loginhandler
def login():
if request.method == "POST":
#Import of email must come after cfg/db load
from SpaceDock.email import Email
email = Email(cfg)
login_manager = LoginManager()
login_manager.init_app(app)
#Import must come after DB loads
from SpaceDock.api import API
api = API(app, documentation, cfg, db, email, profiler, search)
@app.before_first_request
def prepare():
db.init_db()
from SpaceDock.objects import User
@login_manager.user_loader
def load_user(username):
return User.query.filter(User.username == username).first()
login_manager.anonymous_user = lambda: None
if __name__ == '__main__':
if cfg.get_environment() == 'dev':
app.debug = True
app.config['JSON_ADD_STATUS'] = False
app.config['JSON_JSONP_OPTIONAL'] = False
app.secret_key = cfg['secret-key']
app.run(host = cfg['debug-host'], port = cfg.geti('debug-port'))
app = Flask(__name__)
app.config.from_object('config')
db = SQLAlchemy(app)
lm = LoginManager()
lm.init_app(app)
lm.login_message = None
mail = Mail(app)
Bootstrap(app)
lm.login_view = 'login'
migrate = Migrate(app, db)
if not app.debug:
import logging
from logging.handlers import RotatingFileHandler
file_handler = RotatingFileHandler(app.config['LOGFILE'], maxBytes=(1024*1024))
file_handler.setLevel(logging.WARNING)
app.logger.addHandler(file_handler)
bot = praw.Reddit(
client_id=app.config['BOT_REDDIT_CLIENT_ID'],
client_secret=app.config['BOT_REDDIT_CLIENT_SECRET'],
username=app.config['BOT_REDDIT_USERNAME'],
password=app.config['BOT_REDDIT_PASSWORD'],
user_agent=app.config['BOT_REDDIT_USER_AGENT'],
)
from cbbpoll import views, models, admin
lm.anonymous_user = models.AnonymousUser
app.jinja_env.globals['timestamp'] = views.timestamp
from flask_login import LoginManager
from joneame import app
from joneame.database import db
from joneame.mixins import MyAnonymousUserMixin
from joneame.models import User
# initialise the login manager
login_manager = LoginManager(app)
login_manager.anonymous_user = MyAnonymousUserMixin
@login_manager.user_loader
def load_user(id):
query = User.query.options(db.joinedload(User.avatar))
return query.get(int(id))
def get_id(self):
return None
app = Flask(__name__, static_folder='static', static_url_path='/static')
import sys
if "debug" in sys.argv:
print("Flask running in debug mode!")
app.debug = True
app.config.from_object('config.BaseConfig')
app.jinja_env.add_extension('jinja2.ext.do')
db = SQLAlchemy(app)
lm = LoginManager()
lm.anonymous_user = AnonUser
lm.init_app(app)
lm.login_view = 'login'
lm.login_message = 'Please log in to access this page.'
mail = Mail(app)
babel = Babel(app)
csrf = CsrfProtect(app)
if "debug" in sys.argv:
print("Installing debug toolbar!")
toolbar = DebugToolbarExtension(app)
if not app.debug:
import logging
from logging.handlers import RotatingFileHandler
file_handler = RotatingFileHandler('tmp/wlnupdates.log', 'a', 1 * 1024 * 1024, 10)
def get_id(self):
return None
app = Flask(__name__, static_folder='static', static_url_path='/static')
import sys
if "debug" in sys.argv:
print("Flask running in debug mode!")
app.debug = True
app.config.from_object('config.BaseConfig')
app.jinja_env.add_extension('jinja2.ext.do')
db = SQLAlchemy(app)
lm = LoginManager()
lm.anonymous_user = AnonUser
lm.init_app(app)
lm.login_view = 'login'
lm.login_message = 'Please log in to access this page.'
mail = Mail(app)
babel = Babel(app)
csrf = CSRFProtect(app)
if "debug" in sys.argv:
print("Installing debug toolbar!")
toolbar = DebugToolbarExtension(app)
if not app.debug:
import logging
from logging.handlers import RotatingFileHandler
file_handler = RotatingFileHandler('tmp/tob2.log', 'a', 1 * 1024 * 1024, 10)
self.pref.prod_price_region_others = 10000002
self.pref.prod_price_type_minerals = 'buy'
self.pref.prod_price_type_pi = 'buy'
self.pref.prod_price_type_moongoo = 'buy'
self.pref.prod_price_type_others = 'buy'
self.pref.prod_te_implant = 1.00
self.pref.reaction_facility = 5
self.pref.reaction_me_rig = 0
self.pref.reaction_te_rig = 0
self.pref.reaction_security = 'l'
self.pref.reaction_system = 'Rakapas'
self.pref.reaction_manuf_facility = 0
self.pref.reaction_manuf_me_rig = 0
self.pref.reaction_manuf_te_rig = 0
self.pref.reaction_manuf_security = 'h'
self.pref.reaction_manuf_system = 'Jita'
self.pref.reaction_manuf_te_implant = 1.00
self.pref.reaction_price_regions = 10000002
self.pref.reaction_price_type = 'buy'
login_manager = LoginManager()
login_manager.anonymous_user = LazyAnonymous
login_manager.login_view = 'sso.login'
@login_manager.user_loader
def load_user(character_id):
return User.query.get(character_id)
# We log a warning if the version of flask-login is less than FLASK_LOGIN_LIMIT
FLASK_LOGIN_LIMIT = '0.3.0'
from .pwdmanager import userdb, LmfdbUser, LmfdbAnonymousUser
base_url = "http://beta.lmfdb.org"
@login_manager.user_loader
def load_user(userid):
return LmfdbUser(userid)
login_manager.login_view = "users.info"
# this anonymous user has the is_admin() method
login_manager.anonymous_user = LmfdbAnonymousUser
def get_username(uid):
"""returns the name of user @uid"""
return LmfdbUser(uid).name
# globally define user properties and username
@app.context_processor
def ctx_proc_userdata():
userdata = {}
userdata['user_can_write'] = userdb.can_read_write_userdb()
if not userdata['user_can_write']:
from .views.admin import bp as admin
from .views.mod import bp as mod
from .views.errors import bp as errors
from .views.messages import bp as messages
from . import misc, forms, caching
from .socketio import socketio
from .misc import SiteAnon, engine
# /!\ FOR DEBUGGING ONLY /!\
# from werkzeug.contrib.profiler import ProfilerMiddleware
webpack = Webpack()
babel = Babel()
login_manager = LoginManager()
login_manager.anonymous_user = SiteAnon
login_manager.login_view = 'login'
def create_app():
app = Flask(__name__)
app.jinja_env.cache = {}
app.config.update(config.get_flask_dict())
app.config['WEBPACK_MANIFEST_PATH'] = 'manifest.json'
babel.init_app(app)
jwt.init_app(app)
webpack.init_app(app)
socketio.init_app(app, message_queue=config.app.redis_url, cors_allowed_origins="*", async_mode="gevent")
caching.cache.init_app(app)
login_manager.init_app(app)
app = Flask(__name__)
app.config.from_object('config')
db = SQLAlchemy(app)
lm = LoginManager()
lm.init_app(app)
lm.login_message = None
mail = Mail(app)
Bootstrap(app)
lm.login_view = 'login'
migrate = Migrate(app, db)
if not app.debug:
import logging
from logging.handlers import RotatingFileHandler
file_handler = RotatingFileHandler(app.config['LOGFILE'],
maxBytes=(1024 * 1024))
file_handler.setLevel(logging.WARNING)
app.logger.addHandler(file_handler)
bot = praw.Reddit(
client_id=app.config['BOT_REDDIT_CLIENT_ID'],
client_secret=app.config['BOT_REDDIT_CLIENT_SECRET'],
username=app.config['BOT_REDDIT_USERNAME'],
password=app.config['BOT_REDDIT_PASSWORD'],
user_agent=app.config['BOT_REDDIT_USER_AGENT'],
)
from cbbpoll import views, models, admin
lm.anonymous_user = models.AnonymousUser
app.jinja_env.globals['timestamp'] = views.timestamp
bootstrap = Bootstrap() db = SQLAlchemy() login_manager = LoginManager() mail = Mail() dropzone = Dropzone() moment = Moment() whooshee = Whooshee() avatars = Avatars() csrf = CSRFProtect() @login_manager.user_loader def load_user(user_id): from albumy.models import User user = User.query.get(int(user_id)) return user login_manager.login_view = 'auth.login' login_manager.login_message_category = 'warning' login_manager.refresh_view = 'auth.re_authenticate' login_manager.needs_refresh_message_category = 'warning' class Guest(AnonymousUserMixin): def can(self, permission_name): return False @property def is_admin(self): return False login_manager.anonymous_user = Guest
from yams_api.utils.logger import log
from yams.core.dev.users.methods import User, YAMSAnonymousUser
from json import loads, dumps
app = Flask(__name__)
app.config.from_object("config.APP")
app.jinja_env.trim_blocks = True
app.jinja_env.lstrip_blocks = True
# this should only be used for db operations related to the web interface.
# if you are associating models with this, you more than likely want the API DB.
app_db = SQLAlchemy(app)
db = SQLAlchemy(app)
login_manager = LoginManager()
login_manager.init_app(app)
login_manager.anonymous_user = YAMSAnonymousUser
API_HOST = "%s://%s:%s" % (PREFERRED_URL_SCHEME, API.LISTEN_HOST, API.LISTEN_PORT)
@login_manager.user_loader
def load_user():
# we should be serving static assets from the webserver, but put this in anyway
# because hammering the DB or k/v store for N-assets is aggressive
if request.endpoint != 'login' and '/static/' not in request.path:
# use api_key instead and keep user outside of token?
token = request.headers.get('Authorization')
if token is None:
token = request.args.get('token')
if token is not None:
def init_login(app):
login_manager = LoginManager()
login_manager.login_view = 'login.login'
login_manager.anonymous_user = users.MyAnonymousUser
@login_manager.user_loader
def load_user(_id):
return users.get(_id=_id)
login_manager.init_app(app)
login_blueprint = Blueprint("login", __name__)
oauth = OAuth()
twitter = oauth.remote_app('twitter',
base_url='https://api.twitter.com/1.1/',
request_token_url='https://api.twitter.com/oauth/request_token',
access_token_url='https://api.twitter.com/oauth/access_token',
authorize_url='https://api.twitter.com/oauth/authenticate',
app_key='TWITTER'
)
oauth.init_app(app)
@twitter.tokengetter
def get_access_token(token=None):
if current_user.is_authenticated():
token = current_user['token']
return token['oauth_token'], token['oauth_token_secret']
else:
return None
@login_blueprint.route('/oauth-authorized')
@twitter.authorized_handler
def oauth_authorized(resp):
next_url = request.args.get('next')
if resp is None:
flash(u'You denied the request to sign in.')
return redirect(next_url)
token = (
resp['oauth_token'],
resp['oauth_token_secret']
)
username = resp['screen_name']
email = username + "@papertalk.org"
user = users.get(username=username)
if not user:
user = users.create(username, email, token)
login_user(user)
return redirect(next_url)
@login_blueprint.route('/login')
def login():
if current_user.is_authenticated():
return request.referrer
callback_url = url_for('.oauth_authorized', next=request.args.get('next') or request.referrer)
#callback_url = callback_url.replace("http://", "https://")
#print callback_url
return twitter.authorize(callback=callback_url or request.referrer or None)
app.register_blueprint(login_blueprint)
login_manager = LoginManager()
# We log a warning if the version of flask-login is less than FLASK_LOGIN_LIMIT
FLASK_LOGIN_LIMIT = '0.3.0'
from pwdmanager import userdb, LmfdbUser, LmfdbAnonymousUser
base_url = "http://beta.lmfdb.org"
@login_manager.user_loader
def load_user(userid):
return LmfdbUser(userid)
login_manager.login_view = "users.info"
# this anonymous user has the is_admin() method
login_manager.anonymous_user = LmfdbAnonymousUser
def get_username(uid):
"""returns the name of user @uid"""
return LmfdbUser(uid).name
# globally define user properties and username
@app.context_processor
def ctx_proc_userdata():
userdata = {}
userdata['user_can_write'] = userdb.can_read_write_userdb()
if not userdata['user_can_write']:
userdata['userid'] = 'anon'
