def create_app(config=None):
# main
app = Flask(__name__, instance_relative_config=True)
app.config.from_object(os.environ['APP_SETTINGS'])
app.secret_key = os.environ.get('SECRET_KEY', app.config['SECRET_KEY'])
app.register_error_handler(404, page_not_found)
app.register_blueprint(main)
# db
db.init_app(app)
# admin
admin = Admin(name='BBS (admin)',
template_mode='bootstrap3',
index_view=MyAdminIndexView(),
base_template='admin_base.html')
admin.init_app(app)
admin.add_view(MyModelView(Entry, db.session))
# login
login_manager.init_app(app)
return app
def create_app():
app = Flask(__name__)
csrf = CSRFProtect()
csrf.init_app(app)
admin = Admin(name='My App')
# Add views here
app.config['SECRET_KEY'] = "kcavnjgnjvgkldm;c,kefjva"
app.config['SQLALCHEMY_DATABASE_URI'] = "mysql://*****:*****@localhost/projetm2"
db.init_app(app)
from auth import auth as auth_blueprint
app.register_blueprint(auth_blueprint)
from main import main as main_blueprint
app.register_blueprint(main_blueprint)
login_manager = LoginManager()
login_manager.login_view = 'auth.login'
login_manager.init_app(app)
from models import Users,MyModelView
from admin_models import MyAdminIndexView
admin.init_app(app,index_view=MyAdminIndexView())
admin.add_view(MyModelView(Users,db.session))
@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 Users.query.get(int(user_id))
return app
def init_app(app):
admin = Admin(index_view=HomeView())
admin.name = app.config.TITLE
admin.template_mode = "bootstrap3"
admin.base_template = "layout.html"
admin.init_app(app)
admin.add_view(UserAdmin(User, db.session))
def setup_app(app):
"""Register all administration views with the Flask application."""
app.config.setdefault("ADMIN_NAME", "Invenio")
app.config.setdefault("ADMIN_UI_SKIN", "skin-blue")
# Initialize app
admin = Admin(
name=app.config['ADMIN_NAME'],
index_view=AdminIndexView(
menu_icon_type='fa',
menu_icon_value='fa-home'),
base_template="admin_base.html",
template_mode='bootstrap3'
)
# TODO remove when 1.2.1 is released
if not hasattr(admin, 'category_icon_classes'):
admin.category_icon_classes = {}
admin.init_app(app)
# Create registry and run discovery
app.extensions['registry']['admin'] = AdminDiscoveryRegistry(
'admin', app=app, with_setup=True, admin=admin
)
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)
mail.init_app(app)
moment.init_app(app)
db.init_app(app)
login_manager.init_app(app)
from .models import Role, User, Post, Topic, Category
from app.admin.views import MyModelView, MyAdminIndexView, CategoryView, TopicView, PostView, UserView
admin = Admin(index_view=MyAdminIndexView(),
name='GTA VoiceRP Admin Longue',
template_mode='bootstrap3')
admin.init_app(app)
admin.add_view(UserView(User, db.session))
admin.add_view(MyModelView(Role, db.session))
admin.add_view(PostView(Post, db.session))
admin.add_view(TopicView(Topic, db.session))
admin.add_view(CategoryView(Category, db.session))
# Add administrative views here
###ROUTES
#Main
from app.main import main as main_blueprint
app.register_blueprint(main_blueprint)
#Login
from app.auth import auth as auth_blueprint
app.register_blueprint(auth_blueprint)
return app
def create_app():
app = Flask(__name__)
app.debug=True
app.secret_key = 'fddfa'
# 设置配置文件
app.config.from_object('settings.BaseConfig')
# 注册蓝图
app.register_blueprint(app01_blue,url_prefix='/app01')
app.register_blueprint(rbac_blue,url_prefix='/rbac')
# 注册后台管理的组件
flask_admin = Admin(base_template='admin/base_menu.html') # 使用自己的模板，覆盖原来的模板
flask_admin.init_app(app)
# flask_admin.add_view(CustomView(name='cus_name',endpoint='helloworld'))
# 上一句，假如设定了name属性，在页面菜单显示name的值,否则显示customView,
# 设置了endpoint属性，则是会改变url,url就是endpoint的值
models = [Group,User,Role,]
for model in models:
flask_admin.add_view(
# CustomModelView(model, session_conn,name='权限相关')) # 如果设置name属性，则这些表都会显示在一组
CustomModelView(model, session_conn))
# 类似于注册处理这个model表的类
flask_admin.add_view(MenuModelView(Menu,session_conn,endpoint='menu'))
flask_admin.add_view(PermissionModelView(Permission,session_conn,endpoint='permission'))
return app
class PeachAdmin:
__slots__ = ['admin']
def __init__(self, name="Peach-Blog", template_mode="bootstrap3"):
self.admin = Admin(name=name,
template_mode=template_mode,
index_view=PeachAdminIndexView(),
base_template='admin/peach-base.html')
def init_app(self, app, db):
self.admin.init_app(app)
# https://github.com/flask-admin/flask-admin/issues/1474
self.admin.add_view(PeachView(User, db.session, endpoint='PeachUser'))
self.admin.add_view(
PeachPostView(Post, db.session, endpoint='PeachPost'))
self.admin.add_view(PeachView(Tag, db.session, endpoint='PeachTag'))
self.admin.add_view(
PeachView(Comment, db.session, endpoint='PeachComment'))
self.admin.add_view(
PeachView(History, db.session, endpoint='PeachHistory'))
self.admin.add_view(
PeachView(MessageBoard, db.session, endpoint='PeachMessageBoard'))
self.admin.add_view(
PeachView(FriendLink, db.session, endpoint='PeachFriendLink'))
def create_app(config_name):
global db
app = Flask(__name__)
app.config.from_object(config[config_name])
config[config_name].init_app(app)
Bootstrap(app)
db.init_app(app)
login_manager.init_app(app)
admin = Admin(template_mode='bootstrap3', index_view=MyAdminIndexView())
admin.init_app(app)
admin.add_view(CustomAdminModelView(User, db.session))
admin.add_view(AdminModelView(Patient, db.session))
admin.add_view(AdminModelView(Meeting, db.session))
admin.add_view(AdminModelView(Case, db.session))
admin.add_view(AdminModelView(Action, db.session))
admin.add_view(AdminModelView(Attendee, db.session))
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
from .auth import auth as auth_blueprint
app.register_blueprint(auth_blueprint, url_prefix='/auth')
return app
def init_admin(app):
admin = Admin(name="SimpleLogin", template_mode="bootstrap3")
admin.init_app(app, index_view=SLAdminIndexView())
admin.add_view(UserAdmin(User, db.session))
admin.add_view(AliasAdmin(Alias, db.session))
admin.add_view(EmailLogAdmin(EmailLog, db.session))
def create_app(config_name):
app = Flask(__name__)
admin = Admin(base_template='admin/master.html',
template_mode='bootstrap3')
# get the config from config.py
app.config.from_object(config[config_name])
config[config_name].init_app(app)
# register blueprints
from app.core import core as core_blueprint
app.register_blueprint(core_blueprint)
# bind BS, DB, datastore and flask-admin to app
bootstrap.init_app(app)
db.init_app(app)
user_datastore = SQLAlchemyUserDatastore(db, User, Role)
security.init_app(app, user_datastore)
admin.init_app(app)
# init flask-admin views
from app.auth.admin import init as init_auth_admin_models
init_auth_admin_models(admin)
@app.before_first_request
def before_first_request():
init_security(user_datastore)
return app
class AdminView(object):
"""Main Admin class View"""
def __init__(self, app_name):
self.admin = Admin(name=app_name, template_mode='bootstrap3', index_view=MyHomeView())
def init(self, app):
"""Init flask admin"""
self.admin.init_app(app)
self._add_views()
def _add_views(self):
self._add_models_to_menu()
def _add_models_to_menu(self):
ev = EventView(Event, db.session)
self.admin.add_view(ev)
@staticmethod
def init_login(app):
"""Init login"""
login_manager = login.LoginManager()
login_manager.init_app(app)
# Create user loader function
@login_manager.user_loader
def load_user(user_id):
return db.session.query(User).get(user_id)
class AdminView(object):
"""Main Admin class View"""
def __init__(self, app_name):
self.admin = Admin(name=app_name, template_mode='bootstrap3', index_view=MyHomeView())
def init(self, app):
"""Init flask admin"""
self.admin.init_app(app)
self._add_views()
def _add_views(self):
events = EventsView(Event, db.session, name='Events', url='events')
self.admin.add_view(events)
self.admin.add_view(RoleView(Role, db.session, name='Role', url='events/<event_id>/roles'))
profile = ProfileView(User, db.session, name='Profile', url='profile')
self.admin.add_view(profile)
track = TracksView(Track, db.session, name='Track', url='events/<event_id>/tracks')
self.admin.add_view(track)
self.admin.add_view(InviteView(Invite, db.session, name='Invite', url='events/<event_id>/invite'))
self.admin.add_view(SessionView(Session, db.session, name='Session', url='events/<event_id>/session'))
# self.admin.add_view(ev)
# self.admin.add_view(events)
@staticmethod
def init_login(app):
"""Init login"""
login_manager = login.LoginManager()
login_manager.init_app(app)
# Create user loader function
@login_manager.user_loader
def load_user(user_id):
return db.session.query(User).get(user_id)
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)
login_manager.init_app(app)
mongo.init_app(app)
from adminpage.views import (MyAdminIndexView, HomeView,
AdminResult1View)
admin = Admin(name="My Admin",
index_view=MyAdminIndexView(endpoint='admin'))
admin.add_view(HomeView(name='App Home'))
with app.app_context():
admin.add_view(AdminResult1View(mongo.db.results,
name='Result1'))
admin.init_app(app)
# attach routes and custom error pages here
from main import main as main_blueprint
app.register_blueprint(main_blueprint)
from customer import customer as customer_blueprint
app.register_blueprint(customer_blueprint, url_prefix='/customer')
from auth import auth as auth_blueprint
app.register_blueprint(auth_blueprint, url_prefix='/auth')
return app
def apply_orm_admin(app):
from flask_admin import Admin
from app.model_views.base import ModelView
object_origins = {}
for module, items in app.config['ALL_MODEL_BY_MODULE'].items():
for item in items:
object_origins[item] = module
admin = Admin(name='商城后台', template_mode='bootstrap3')
for model_name, module_name in object_origins.items():
model_module = __import__('models.{}'.format(module_name), globals(), fromlist=('***'), level=1)
model = getattr(model_module, model_name)
try:
# model_view_module 可能不存在
model_view_module = __import__('model_views.{}'.format(module_name), globals(), fromlist=('***'),
level=1)
model_view = getattr(model_view_module, '{}View'.format(model_name), ModelView)
except ModuleNotFoundError as e:
model_view = ModelView
# admin添加model_view
admin.add_view(model_view(model, db.session))
apply_file_admin(admin)
admin.init_app(app, url='/admin')
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)
login_manager.init_app(app)
mongo.init_app(app)
from adminpage.views import (MyAdminIndexView, HomeView, AdminResult1View)
admin = Admin(name="My Admin",
index_view=MyAdminIndexView(endpoint='admin'))
admin.add_view(HomeView(name='App Home'))
with app.app_context():
admin.add_view(AdminResult1View(mongo.db.results, name='Result1'))
admin.init_app(app)
# attach routes and custom error pages here
from main import main as main_blueprint
app.register_blueprint(main_blueprint)
from customer import customer as customer_blueprint
app.register_blueprint(customer_blueprint, url_prefix='/customer')
from auth import auth as auth_blueprint
app.register_blueprint(auth_blueprint, url_prefix='/auth')
return app
class AdminView(object):
"""Main Admin class View"""
def __init__(self, app_name):
self.admin = Admin(name=app_name,
template_mode='bootstrap3',
index_view=MyHomeView())
def init(self, app):
"""Init flask admin"""
self.admin.init_app(app)
self._add_views()
def _add_views(self):
self._add_models_to_menu()
def _add_models_to_menu(self):
ev = EventView(Event, db.session)
self.admin.add_view(ev)
@staticmethod
def init_login(app):
"""Init login"""
login_manager = login.LoginManager()
login_manager.init_app(app)
# Create user loader function
@login_manager.user_loader
def load_user(user_id):
return db.session.query(User).get(user_id)
def create_app():
# 配置日志
app = Flask(__name__)
# 加载配置
app.config.from_object(Config)
# 初始化数据库
db.init_app(app)
# admin = Admin(name='工单审批后台管理系统',index_view=MyAdminIndexView(), template_mode='bootstrap3')
from service.modules.admin.login import MyAdminIndexView
global admin
admin = Admin(name='工单审批后台管理系统', index_view=MyAdminIndexView(), template_mode='bootstrap3')
admin.init_app(app)
babel = Babel(app)
app.config['BABEL_DEFAULT_LOCALE'] = 'zh_CN'
# 初始化 redis 存储对象
global redis_store
redis_store = StrictRedis(host=Config.REDIS_HOST,port=Config.REDIS_PORT,decode_responses=True)
# 开启当前项目CSRF 保护
# CSRFProtect(app)
login_manager = login.LoginManager()
login_manager.init_app(app)
# Create user loader function
@login_manager.user_loader
def load_user(user_id):
from .model.model import SuperUser
return db.session.query(SuperUser).get(user_id)
# @app.after_request
# def after_request(response):
# csrf_token = generate_csrf()
# response.set_cookie("csrf_token",csrf_token)
#
# return response
# 注册蓝图
from .modules.passport import passport_blu
app.register_blueprint(passport_blu)
from .modules.form import form_blu
app.register_blueprint(form_blu)
from .modules.my_submit import my_submit_blu
app.register_blueprint(my_submit_blu)
from .modules.my_approve import my_approve_blu
app.register_blueprint(my_approve_blu)
from .modules.service_counter import service_counter_blu
app.register_blueprint(service_counter_blu)
from .modules.my_task import my_task_blu
app.register_blueprint(my_task_blu)
from .modules.user_info import user_info_blu
app.register_blueprint(user_info_blu)
return app
def create_module(app, **kwargs):
from .views import CustomView, UserModelView
from .. import db
from .models import User
admin = Admin(index_view=views.MyAdminIndexView())
admin.init_app(app)
admin.add_view(CustomView(name='Custom'))
admin.add_view(UserModelView(User, db.session))
def configure_admin(app):
admin = Admin(index_view=IndexAdminView(endpoint='admin'))
admin.init_app(app)
admin.add_link(MenuLink(name='Logout', url='/user/logout'))
admin.add_view(UserAdminView(User, sqldb.session, endpoint='user-admin'))
admin.add_view(RoleAdminView(Role, sqldb.session, endpoint="role-admin"))
return app
def init_admin(app):
admin = Admin(name="SimpleLogin", template_mode="bootstrap3")
admin.init_app(app, index_view=SLAdminIndexView())
admin.add_view(SLModelView(User, db.session))
admin.add_view(SLModelView(Client, db.session))
admin.add_view(SLModelView(Alias, db.session))
admin.add_view(SLModelView(ClientUser, db.session))
class AdminView(object):
"""Main Admin class View"""
def __init__(self, app_name):
self.admin = Admin(name=app_name, template_mode='bootstrap3', index_view=MyHomeView(
name='Home',
url='/'
), static_url_path='/static')
def init(self, app):
"""Init flask admin"""
self.admin.init_app(app)
self._add_views()
def _add_views(self):
self.admin.add_view(EventDetailView(name='Event Detail', url='/e', endpoint="event_detail"))
self.admin.add_view(ExploreView(name='Explore', url='/explore', endpoint="explore"))
self.admin.add_view(BasicPagesView(name='Page', url='/'))
self.admin.add_view(MySessionView(name='MySessions', url='/events/mysessions', endpoint="my_sessions"))
self.admin.add_view(EventsView(name='Events', url='/events', endpoint="events"))
self.admin.add_view(SpeakersView(name='Speakers', url='/events/<event_id>/speakers', endpoint="event_speakers"))
self.admin.add_view(SponsorsView(name='Sponsors', url='/events/<event_id>/sponsors', endpoint="event_sponsors"))
self.admin.add_view(SessionsView(name='Sessions', url='/events/<event_id>/sessions', endpoint="event_sessions"))
self.admin.add_view(SchedulerView(name='Scheduler', url='/events/<event_id>/scheduler', endpoint="event_scheduler"))
self.admin.add_view(ExportView(name='Export', url='/events/<event_id>/export', endpoint="event_export"))
self.admin.add_view(RoleView(name='Role', url='/events/<event_id>/roles', endpoint="event_roles"))
self.admin.add_view(ProfileView(name='Profile', url='/profile', endpoint="profile"))
self.admin.add_view(InviteView(name='Invite', url='/events/<event_id>/invite', endpoint="event_invites"))
self.admin.add_view(SettingsView(name='Settings', url='/settings', endpoint="settings"))
self.admin.add_view(SuperAdminView(name='Admin', url='/admin/', endpoint="sadmin"))
self.admin.add_view(SuperAdminEventsView(name='Events', url='/admin/events', endpoint="sadmin_events"))
self.admin.add_view(SuperAdminMySessionView(name='Sessions', url='/admin/sessions', endpoint="sadmin_sessions"))
self.admin.add_view(SuperAdminUsersView(name='Users', url='/admin/users', endpoint="sadmin_users"))
self.admin.add_view(SuperAdminPermissionsView(name='Permissions', url='/admin/permissions', endpoint="sadmin_permissions"))
self.admin.add_view(SuperAdminReportsView(name='Reports', url='/admin/reports', endpoint="sadmin_reports"))
self.admin.add_view(SuperAdminLogsView(name='Logs', url='/admin/logs', endpoint="sadmin_logs"))
self.admin.add_view(SuperAdminSettingsView(name='Settings', url='/admin/settings', endpoint="sadmin_settings"))
self.admin.add_view(SuperAdminMessagesView(name='Messages', url='/admin/messages', endpoint="sadmin_messages"))
self.admin.add_view(SuperAdminPagesView(name='Pages', url='/admin/pages', endpoint="sadmin_pages"))
self.admin.add_view(SuperAdminModulesView(name='Modules', url='/admin/modules', endpoint="sadmin_modules"))
@staticmethod
def init_login(app):
from flask import request, url_for, redirect
"""Init login"""
login_manager = login.LoginManager()
login_manager.init_app(app)
# Create user loader function
@login_manager.user_loader
def load_user(user_id):
return db.session.query(User).get(user_id)
@login_manager.unauthorized_handler
def unauthorized():
return redirect(url_for('admin.login_view', next=request.url))
def init_admin(app):
global admin
if admin == None:
admin = Admin(template_mode="bootstrap3", index_view=AdminView())
admin.init_app(app)
admin.add_view(UserAdmin(User, db.session))
admin.add_link(MenuLink(name="Logout", url="/logout"))
admin.add_link(MenuLink(name="Go back", url="/"))
return admin
def init_admin(app):
admin = Admin(name="SimpleLogin", template_mode="bootstrap4")
admin.init_app(app, index_view=SLAdminIndexView())
admin.add_view(UserAdmin(User, db.session))
admin.add_view(AliasAdmin(Alias, db.session))
admin.add_view(MailboxAdmin(Mailbox, db.session))
admin.add_view(EmailLogAdmin(EmailLog, db.session))
admin.add_view(LifetimeCouponAdmin(LifetimeCoupon, db.session))
admin.add_view(ManualSubscriptionAdmin(ManualSubscription, db.session))
def register(app, db):
admin = Admin(name="Transcript Hero Admin",
index_view=SecureAdminIndexView())
admin.add_view(AdminModelView(Role, db._session))
admin.add_view(UserAdminModelView(User, db._session))
admin.add_view(SubscriptionAdminModelView(Subscription, db._session))
admin.add_view(TranscriptAdminModelView(db))
admin.add_view(TranscriptSettingsAdminModelView(db))
admin.add_view(GradingScaleAdminModelView(GradingScale, db._session))
admin.init_app(app)
def admin():
"""run admin"""
a = Admin()
a.init_app(app)
a.add_view(ModelView(Example, db.session))
@app.teardown_request
def remove_session(exception=None):
db.session.remove()
app.run()
def setup_admin(app, db, aligned_volume):
index_view = MyAdminIndexView(name=f"{aligned_volume}_admin",
endpoint=f'{aligned_volume}',
url=f'/info/admin/{aligned_volume}')
admin = Admin(name=f'{aligned_volume}_admin2',
endpoint=f'{aligned_volume}',
index_view=index_view)
admin.add_view(
SuperAdminView(Metadata, db.session,
name=f'{aligned_volume}_metadata'))
admin.init_app(app)
return admin
def init_admin(app):
global admin
if admin == None:
admin = Admin(template_mode="bootstrap3", index_view=AdminView())
admin.init_app(app)
admin.add_view(UserAdmin(User, db.session))
admin.add_view(ProtectedView(Course, db.session))
admin.add_view(ProtectedView(Follow, db.session))
admin.add_view(ProtectedView(ParticipationCode, db.session))
admin.add_view(ProtectedView(ParticipationRedeem, db.session))
admin.add_link(MenuLink(name="Logout", url="/logout"))
admin.add_link(MenuLink(name="Go back", url="/"))
return admin
def init_app(self, app):
admin = Admin(template_mode='bootstrap4',
base_template='adminlte/base.html')
admin.init_app(app)
self.admin = admin
blueprint = Blueprint('adminlte',
__name__,
template_folder='templates',
static_folder='static',
static_url_path=app.static_url_path +
'/adminlte')
app.register_blueprint(blueprint)
def register_admin(app):
"""Register Flask Admin.
This extension doesn't behave like the others; that's why we had to initialise it here, not outside.
See https://github.com/flask-admin/flask-admin/issues/910
"""
admin = Admin(name='Tegenaria',
template_mode='bootstrap3',
index_view=AdminIndexView(url='/'))
admin.init_app(app)
admin.add_view(ApartmentModelView(Apartment, db.session))
admin.add_view(ModelView(Opinion, db.session))
admin.add_view(PinModelView(Pin, db.session))
return None
def create_app(db):
app = Flask(__name__)
app.register_blueprint(index_blueprint, url_prefix='/')
app.register_blueprint(member_blueprint, url_prefix='/member/')
app.config['SECRET_KEY'] = '\xca\x0c\x86\x04\x98@\x02b\x1b7\x8c\x88]\x1b\xd7"+\xe6px@\xc3#\\'
app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql://*****:*****@localhost/myweb'
login = LoginManager()
bootstrap = Bootstrap()
admin = Admin(name="APP admin", template_mode='bootstrap3')
admin.add_view(myview.MyView(name='Hello'))
admin.init_app(app)
bootstrap.init_app(app)
login.init_app(app)
db.init_app(app)
return app
def init_app(app):
admin = Admin(name=_("honmaple"),
index_view=AdminIndexView(
template="admin/index.html",
url=app.config.get("ADMIN_URL", "/"),
),
template_mode="bootstrap3")
admins = [
"maple.admin",
"maple.blog.admin",
"maple.storage.admin",
]
[import_string(i).init_admin(admin) for i in admins]
admin.init_app(app)
def configure_admin(app):
admin = Admin(index_view=AskIndexView(),
name='Ask',
template_mode='bootstrap3')
admin.init_app(app)
with app.app_context():
admin.add_link(MenuLink('Ask External', endpoint='main.index'))
admin.add_view(ProviderView(Provider, db.session))
admin.add_view(AddressView(Address, db.session))
admin.add_view(ReviewView(Review, db.session))
admin.add_view(UserView(User, db.session))
admin.add_view(CategoryView(Category, db.session))
admin.add_view(AskModelView(Sector, db.session))
admin.add_view(GroupView(Group, db.session))
admin.add_view(ProviderSuggestionView(Provider_Suggestion, db.session))
def create_module(app, **kwargs):
from .view import CustomView, UserModelView, CustomFileAdmin
from .models import User
from .. import db
# admin = Admin(index_view=CustomView(), template_mode="bootstrap3")
admin = Admin(index_view=view.MyAdminIndexView())
admin.init_app(app)
admin.add_view(CustomView(name='Custom'))
admin.add_view(UserModelView(User, db.session))
admin.add_view(
CustomFileAdmin(app.static_folder, '/static/', name='Static Files'))
# admin.add_view(UserAdminView(User, db.session, endpoint="users"))
with warnings.catch_warnings():
warnings.filterwarnings('ignore', 'Fields missing from ruleset',
UserWarning)
def init_app(app):
# Flask-DebugToolbar
debug_toolbar.init_app(app)
# Celery
cel.init_app(app)
# CSRF protection
csrf.init_app(app)
# SQLAlchemy
db.init_app(app)
# User
user_manager.init_app(app, db, User)
user_manager.email_manager = CustomEmailManager(app)
# Flask-Gravatar
gravatar.init_app(app)
# Flask-Migrate
migrate.init_app(
app=app,
db=db,
directory=str(Path(__file__).resolve().parent / "migrations"),
)
# Reverse proxy should used HTTPS
if app.config["USE_REVERSE_PROXY"]:
app.config["PREFERRED_URL_SCHEME"] = "https"
app.wsgi_app = ProxyFix(app.wsgi_app, x_proto=1, x_host=1)
# API Ratelimit
limiter.init_app(app)
# Flask-Admin
admin = Admin(
name="OpenCVE Admin", template_mode="bootstrap3", index_view=HomeView()
)
admin.init_app(app)
with warnings.catch_warnings():
warnings.filterwarnings("ignore", "Fields missing from ruleset")
admin.add_view(UserModelView(User, db.session))
admin.add_view(CveModelView(Cve, db.session))
admin.add_view(EventModelView(Event, db.session))
admin.add_view(VendorModelView(Vendor, db.session))
admin.add_view(ProductModelView(Product, db.session))
admin.add_link(MenuLink(name="Tasks", url="/admin/tasks"))
def init_app_admin():
app = get_base_app()
app.logger.debug("Run ices modules")
run_ices_modules(app.config['SQLALCHEMY_DATABASE_URI'])
app.before_request(get_current_user)
app.logger.debug("Register blueprints")
register_blueprints_admin(app)
login_manager = LoginManager(app)
login_manager.login_view = 'auth.login'
login_manager.user_loader(load_user)
user_db = SQLAlchemy(app)
db_adapter = SQLAlchemyAdapter(user_db, type('UserModel',
(user_db.Model, User), {}))
user_manager = UserManager(db_adapter, app)
admin = Admin(name="Mistofm", template_mode="bootstrap3",
index_view=IndexView(url=config.ADMIN_URL_PREFIX))
admin.init_app(app)
db_session, connection, engine = get_db_session(app.config.get('SQLALCHEMY_DATABASE_URI'))
# remove db session each time when close connection in
# order to refresh data and get new session
@app.teardown_request
def teardown(err):
db_session.remove()
connection.close()
engine.dispose()
db = getattr(g, 'db', None)
sql_connection = getattr(g, 'db_connection', None)
g_engine = getattr(g, 'engine', None)
if db is not None:
if err:
db.rollback()
db.remove()
if sql_connection:
sql_connection.close()
if g_engine:
g_engine.dispose()
return err
admin.add_view(StationView(Station, db_session))
admin.add_view(ImageView(Image, db_session))
admin.add_view(MusicView(Music, db_session))
admin.add_view(PlaylistView(Playlist, db_session))
admin.add_view(StationIcesView(StationIces, db_session))
admin.add_view(PlaylistMusicView(PlaylistMusic, db_session))
admin.add_view(AdminView(HtmlHeader, db_session))
admin.add_view(GeneralView(General, db_session))
admin.add_link(MenuLink(name='Logout', category='', url="/logout"))
return app
def setup_app(app):
"""
Register all administration views with the Flask application
"""
app.config.setdefault("ADMIN_NAME", "Invenio")
# Initialize app
admin = Admin(
name=app.config['ADMIN_NAME'],
index_view=AdminIndexView(),
base_template="admin_base.html",
template_mode='bootstrap3'
)
admin.init_app(app)
# Create registry and run discovery
app.extensions['registry']['admin'] = AdminDiscoveryRegistry(
'admin', app=app, with_setup=True, admin=admin
)
def init_administration(self, index_view=None, user=None, role=None):
"""
Initialize the Administrative GUI.
:param index_view: the View that will act as the index page of the admin GUI.
:type index_view: AdminIndexView
:returns: None
The administration GUI is substantially derived from `Flask-Admin
<http://flask-admin.readthedocs.org/en/latest/>`_. When this function
is called, it will instantiate blueprints so the application serves
the admin GUI via the URL http://localhost/admin.
Typically, you will want to call this function even if you override
it. The following example illustrates using super() to invoke this
administration() function from within your own application.
>>> admin = super(MyApp, self).administration(
>>> index_view=MyApp.modelviews.RedirectView(name="Home")
>>> )
"""
admin = Admin(
name=self.app.config["PROJECT_NAME"],
base_template='admin/login_base.html',
index_view=index_view or ForceLoginView(name="Home")
)
from .. import db
if not user or not role:
raise Exception
admin.init_app(self.app)
admin.add_view(UserView(user, db.session, category="Admin"))
admin.add_view(AdminModelView(role, db.session, category="Admin"))
return admin
def create_app(settings_override=None):
"""Create frontend application.
:param settings_override: settings that need to override Default to None.
"""
app = appfactory.create_app(__name__, __path__, settings_override)
app.json_encoder = JSONEncoder
from .. import models
#这个只有网页上使用，放在这里的最大原因是为了防止在单元测试时重复增加adminview的endpoint
admin = Admin(name='Admin', base_template='admin/admin_base.html')
collect_admin_views(models, admin, app)
admin.init_app(app)
# Register custom error handlers
if not app.debug:
for e in [500, 404, 403]:
app.errorhandler(e)(handle_error)
init_context_processor(app)
return app
def create_app(dev_server=False):
app = Flask(__name__)
app.config.from_envvar('SETTINGS_FILE')
app.jinja_options['extensions'].append('jinja2.ext.do')
if install_logging:
create_logging_manager(app)
# Flask has now kindly installed its own log handler which we will summarily remove.
app.logger.propagate = 1
app.logger.handlers = []
if not app.debug:
logging.root.setLevel(logging.INFO)
else:
logging.root.setLevel(logging.DEBUG)
from apps.metrics import request_duration, request_total
# Must be run before crsf.init_app
@app.before_request
def before_request():
request._start_time = time.time()
@app.after_request
def after_request(response):
try:
request_duration.labels(request.endpoint, request.method).observe(
time.time() - request._start_time)
except AttributeError:
logging.exception("Request without _start_time - check app.before_request ordering")
request_total.labels(request.endpoint, request.method, response.status_code).inc()
return response
for extension in (cdn, csrf, cache, db, mail, assets, toolbar):
extension.init_app(app)
def log_email(message, app):
app.logger.info("Emailing %s: %r", message.recipients, message.subject)
email_dispatched.connect(log_email)
cors_origins = ['https://map.emfcamp.org', 'https://wiki.emfcamp.org']
if app.config.get('DEBUG'):
cors_origins = ['http://localhost:8080', 'https://maputnik.github.io']
CORS(app, resources={r"/api/*": {"origins": cors_origins}},
supports_credentials=True)
migrate.init_app(app, db)
login_manager.setup_app(app, add_context_processor=True)
app.login_manager.login_view = 'users.login'
from models.user import User, load_anonymous_user
from models import site_state, feature_flag
@login_manager.user_loader
def load_user(userid):
user = User.query.filter_by(id=userid).first()
if user:
set_user_id(user.email)
return user
login_manager.anonymous_user = load_anonymous_user
if app.config.get('TICKETS_SITE'):
global gocardless_client
gocardless_client = gocardless_pro.Client(access_token=app.config['GOCARDLESS_ACCESS_TOKEN'],
environment=app.config['GOCARDLESS_ENVIRONMENT'])
stripe.api_key = app.config['STRIPE_SECRET_KEY']
@app.before_request
def load_per_request_state():
site_state.get_states()
feature_flag.get_db_flags()
if app.config.get('NO_INDEX'):
# Prevent staging site from being displayed on Google
@app.after_request
def send_noindex_header(response):
response.headers['X-Robots-Tag'] = 'noindex, nofollow'
return response
@app.before_request
def simple_cache_warning():
if not dev_server and app.config.get('CACHE_TYPE', 'null') == 'simple':
logging.warn('Per-process cache being used outside dev server - refreshing will not work')
@app.after_request
def send_security_headers(response):
use_hsts = app.config.get('HSTS', False)
if use_hsts:
max_age = app.config.get('HSTS_MAX_AGE', 3600 * 24 * 7 * 4)
response.headers['Strict-Transport-Security'] = 'max-age=%s' % max_age
response.headers['X-Frame-Options'] = 'deny'
response.headers['X-Content-Type-Options'] = 'nosniff'
return response
@app.errorhandler(404)
def handle_404(e):
return render_template('errors/404.html'), 404
@app.errorhandler(500)
def handle_500(e):
return render_template('errors/500.html'), 500
@app.shell_context_processor
def shell_imports():
ctx = {}
# Import models and constants
import models
for attr in dir(models):
if attr[0].isupper():
ctx[attr] = getattr(models, attr)
# And just for convenience
ctx['db'] = db
return ctx
from apps.common import load_utility_functions
load_utility_functions(app)
from apps.base import base
from apps.metrics import metrics
from apps.users import users
from apps.tickets import tickets
from apps.payments import payments
from apps.cfp import cfp
from apps.cfp_review import cfp_review
from apps.schedule import schedule
from apps.arrivals import arrivals
from apps.api import api_bp
app.register_blueprint(base)
app.register_blueprint(users)
app.register_blueprint(metrics)
app.register_blueprint(tickets)
app.register_blueprint(payments)
app.register_blueprint(cfp)
app.register_blueprint(cfp_review, url_prefix='/cfp-review')
app.register_blueprint(schedule)
app.register_blueprint(arrivals, url_prefix='/arrivals')
app.register_blueprint(api_bp, url_prefix='/api')
if app.config.get('VOLUNTEERS'):
from apps.volunteer import volunteer
app.register_blueprint(volunteer, url_prefix='/volunteer')
from flask_admin import Admin
from apps.volunteer.flask_admin_base import VolunteerAdminIndexView
global volunteer_admin
volunteer_admin = Admin(url='/volunteer/admin', name='EMF Volunteers',
template_mode='bootstrap3',
index_view=VolunteerAdminIndexView(url='/volunteer/admin'),
base_template='volunteer/admin/flask-admin-base.html')
volunteer_admin.endpoint_prefix = 'volunteer_admin'
volunteer_admin.init_app(app)
import apps.volunteer.admin # noqa: F401
from apps.admin import admin
app.register_blueprint(admin, url_prefix='/admin')
from apps.notification import notify
app.register_blueprint(notify, url_prefix='/notify')
return app
def create_app(config=None, register_blueprints=True, init_admin=True):
"""Create a Flask app"""
app = Flask('spkrepo')
# Configuration
app.config.from_object(default_config)
app.config.from_envvar('SPKREPO_CONFIG', silent=True)
if config is not None:
app.config.from_object(config)
# Extra template path
if app.config['TEMPLATE_PATH'] is not None:
app.jinja_loader = jinja2.ChoiceLoader([
jinja2.FileSystemLoader(app.config['TEMPLATE_PATH']),
app.jinja_loader
])
# Blueprints
if register_blueprints:
app.register_blueprint(frontend)
app.register_blueprint(api, url_prefix='/api')
app.register_blueprint(nas, url_prefix='/nas')
# Admin
if init_admin:
admin = Admin(index_view=IndexView())
admin.add_view(UserView())
admin.add_view(ArchitectureView())
admin.add_view(FirmwareView())
admin.add_view(ScreenshotView())
admin.add_view(PackageView())
admin.add_view(VersionView())
admin.add_view(BuildView())
admin.init_app(app)
# SQLAlchemy
db.init_app(app)
# Security
security.init_app(app, user_datastore, confirm_register_form=SpkrepoConfirmRegisterForm)
# Migrate
migrate.init_app(app, db, directory=app.config['MIGRATE_DIRECTORY'])
# Mail
mail.init_app(app)
# Cache
cache.init_app(app)
# Debug Toolbar
debug_toolbar.init_app(app)
# Jinja2 helpers
@app.template_filter()
def is_hidden_field(field):
return isinstance(field, HiddenField)
@app.template_filter()
def sort_fields(form, field_names=None):
fields = []
for field in form:
if field.name in field_names:
fields.insert(field_names.index(field.name), field)
else:
fields.append(field)
return fields
return app
class AdministrationApplication(object):
def __init__(self, app, cfg_manager, core_server, bypass_authz = False):
super(AdministrationApplication, self).__init__()
app.json_encoder = CustomJSONEncoder
self.cfg_manager = cfg_manager
pub_directory = os.path.join(os.path.abspath(self.cfg_manager.get('deployment_dir', '')), 'pub')
self.config = cfg_manager
db.initialize(cfg_manager)
self.core_server = core_server
db_session = scoped_session(sessionmaker(autocommit=False, autoflush=False, bind=db.engine))
files_directory = cfg_manager.get_doc_value(configuration_doc.CORE_STORE_STUDENTS_PROGRAMS_PATH)
core_server_url = cfg_manager.get_value( 'core_server_url', '' )
self.script_name = urlparse.urlparse(core_server_url).path.split('/weblab')[0] or ''
self.app = app
static_folder = os.path.abspath(os.path.join(os.path.dirname(web.__file__), 'static'))
# Not allowed
@app.route('/weblab/not_allowed')
def not_allowed():
return "You are logged in, but not allowed to see this content. Please log in with a proper account"
# Back
@app.route('/weblab/back')
def back_to_client():
return redirect(url_for('core_webclient.labs'))
################################################
#
# Administration panel for administrators
#
#
admin_url = '/weblab/admin'
category_system = lazy_gettext("System")
category_users = lazy_gettext("Users")
category_logs = lazy_gettext("Logs")
category_experiments = lazy_gettext("Experiments")
category_permissions = lazy_gettext("Permissions")
self.admin = Admin(index_view = admin_views.HomeView(db_session, url = admin_url),name = lazy_gettext('WebLab-Deusto Admin'), url = admin_url, endpoint = admin_url, base_template = 'weblab-master.html', template_mode = 'bootstrap3')
self.admin.weblab_admin_app = self
self.admin.add_view(admin_views.SystemProperties(db_session, category = category_system, name = lazy_gettext('Settings'), endpoint = 'system/settings', url='settings'))
self.admin.add_view(admin_views.AuthsPanel(db_session, category = category_system, name = lazy_gettext('Authentication'), endpoint = 'system/auth', url='auth'))
if not os.path.exists(pub_directory):
try:
os.mkdir(pub_directory)
except (IOError, OSError) as e:
print("WARNING: %s not found. Create it to upload files to it." % pub_directory)
if os.path.exists(pub_directory):
self.admin.add_view(admin_views.AdministratorFileAdmin(pub_directory, category = category_system, name = lazy_gettext('Public directory'), endpoint = 'system/pub', url='pub'))
self.admin.add_view(admin_views.UsersAddingView(db_session, category = category_users, name = lazy_gettext('Add multiple users'), endpoint = 'users/multiple'))
self.admin.add_view(admin_views.UsersPanel(db_session, category = category_users, name = lazy_gettext('Users'), endpoint = 'users/users', url='users'))
self.admin.add_view(admin_views.GroupsPanel(db_session, category = category_users, name = lazy_gettext('Groups'), endpoint = 'users/groups', url='groups'))
self.admin.add_view(admin_views.InvitationsPanel(db_session, category = category_users, name = lazy_gettext('Invitations'),
endpoint = 'users/invitations', url='invitations'))
self.admin.add_view(admin_views.UserUsedExperimentPanel(files_directory, db_session, category = category_logs, name = lazy_gettext('User logs'), endpoint = 'logs/users', url='logs'))
self.admin.add_view(admin_views.ExperimentCategoryPanel(db_session, category = category_experiments, name = lazy_gettext('Categories'), endpoint = 'experiments/categories', url='experiments/categories'))
self.admin.add_view(admin_views.ExperimentPanel(db_session, category = category_experiments, name = lazy_gettext('Experiments'), endpoint = 'experiments/experiments', url='experiments'))
# TODO: Until finished, do not display
# self.admin.add_view(admin_views.SchedulerPanel(db_session, category = category_experiments, name = lazy_gettext('Schedulers'), endpoint = 'experiments/schedulers'))
self.admin.add_view(admin_views.PermissionsAddingView(db_session, category = category_permissions, name = lazy_gettext('Create'), endpoint = 'permissions/create', url='permissions'))
self.admin.add_view(admin_views.UserPermissionPanel(db_session, category = category_permissions, name = lazy_gettext('User'), endpoint = 'permissions/user'))
self.admin.add_view(admin_views.GroupPermissionPanel(db_session, category = category_permissions, name = lazy_gettext('Group'), endpoint = 'permissions/group'))
self.admin.add_view(admin_views.RolePermissionPanel(db_session, category = category_permissions, name = lazy_gettext('Roles'), endpoint = 'permissions/role'))
self.admin.add_link(MenuLink(endpoint='instructor.index', name = lazy_gettext('Instructor panel'), icon_type='glyph', icon_value='glyphicon-stats'))
self.admin.add_link(MenuLink(endpoint='profile.index', name = lazy_gettext('My profile'), icon_type='glyph', icon_value='glyphicon-user'))
self.admin.add_link(MenuLink(endpoint = 'back_to_client', name = lazy_gettext('Back'), icon_type='glyph', icon_value='glyphicon-log-out'))
self.admin.init_app(self.app)
self.full_admin_url = self.script_name + admin_url
################################################
#
# Profile panel
#
profile_url = '/weblab/profile'
self.profile = Admin(index_view = profile_views.ProfileHomeView(db_session, url = profile_url, endpoint = 'profile'),name = lazy_gettext('WebLab-Deusto profile'), url = profile_url, endpoint = profile_url, base_template = 'weblab-master.html', template_mode='bootstrap3')
self.profile.weblab_admin_app = self
self.profile.add_view(profile_views.ProfileEditView(db_session, name = lazy_gettext('Edit'), endpoint = 'edit'))
self.profile.add_view(profile_views.MyAccessesPanel(files_directory, db_session, name = lazy_gettext('My accesses'), endpoint = 'accesses'))
self.profile.add_link(MenuLink(endpoint = 'back_to_client', name = lazy_gettext('Back'), icon_type='glyph', icon_value='glyphicon-log-out'))
self.profile.init_app(self.app)
################################################
#
# Instructors panel
#
# TODO. There should be able a new M2M relation between instructors and groups.
#
# Instructor should be able to:
#
# a) Create new groups (of which they are in charge)
# b) Make other instructors in charge of these groups
# c) Add students (and only students) to the system; forcing a group
# d) Edit users (only students; of those groups that the administrator is in charge of)
# e) Assign permissions on these courses
# f) Manage the permissions on these courses
# g) See the logs of their own students
# h) See a panel with analytics of each of these groups (this panel is common to the administrator, and has not been implemented)
instructor_url = '/weblab/instructor'
instructor_home = instructor_views.InstructorHomeView(db_session, url = instructor_url, endpoint = 'instructor')
instructor_home.static_folder = static_folder
self.instructor = Admin(index_view = instructor_home, name = lazy_gettext("Weblab-Deusto instructor"), url = instructor_url, endpoint = instructor_url, base_template = 'weblab-master.html', template_mode='bootstrap3')
self.instructor.weblab_admin_app = self
category_general = lazy_gettext("General")
category_stats = lazy_gettext("Stats")
self.instructor.add_view(instructor_views.UsersPanel(db_session, category = category_general, name = lazy_gettext('Users'), endpoint = 'users'))
self.instructor.add_view(instructor_views.GroupsPanel(db_session, category = category_general, name = lazy_gettext('Groups'), endpoint = 'groups'))
self.instructor.add_view(instructor_views.UserUsedExperimentPanel(db_session, category = category_general, name = lazy_gettext('Raw accesses'), endpoint = 'logs'))
self.instructor.add_view(instructor_views.GroupStats(db_session, category = category_stats, name = lazy_gettext('Group'), endpoint = 'stats/groups'))
self.instructor.add_link(MenuLink(endpoint='profile.index', name = lazy_gettext('My profile'), icon_type='glyph', icon_value='glyphicon-user'))
self.instructor.add_link(MenuLink(endpoint = 'back_to_client', name = lazy_gettext('Back'), icon_type='glyph', icon_value='glyphicon-log-out'))
self.instructor.init_app(self.app)
################################################
#
# Other
#
self.bypass_authz = bypass_authz
@property
def db(self):
return self.core_server.db
def get_db(self):
return self.core_server.db
def is_admin(self):
if self.bypass_authz:
return True
try:
session_id = (request.cookies.get('weblabsessionid') or '').split('.')[0]
if not session_id:
return False
with weblab_api(self.core_server, session_id = session_id):
is_admin = weblab_api.is_admin
return is_admin
except:
traceback.print_exc()
return False
def get_user_role(self):
if self.bypass_authz:
return 'admin'
try:
session_id = (request.cookies.get('weblabsessionid') or '').split('.')[0]
if session_id:
try:
with weblab_api(self.core_server, session_id = session_id):
user_info = weblab.core.server.get_user_information()
except SessionNotFoundError:
# Gotcha
traceback.print_exc()
else:
return user_info.role.name
return None
except:
traceback.print_exc()
return None
def _reserve_fake_session(self):
fake_names = ('student1', 'porduna', 'user7', 'admin')
exc = None
for fake_name in fake_names:
try:
session_id, route = self.core_server._reserve_session(ValidDatabaseSessionId(fake_name, 'administrator'))
except Exception as exc:
pass
else:
return session_id, route
raise exc
def get_permissions(self):
if self.bypass_authz:
session_id, _ = self._reserve_fake_session()
with weblab_api(self.core_server, session_id = session_id.id):
return weblab.core.server.get_user_permissions()
session_id = (request.cookies.get('weblabsessionid') or '').split('.')[0]
if session_id:
try:
with weblab_api(self.core_server, session_id = session_id):
return weblab.core.server.get_user_permissions()
except:
traceback.print_exc()
return None
def get_user_information(self):
if self.bypass_authz:
session_id, _ = self._reserve_fake_session()
with weblab_api(self.core_server, session_id = session_id.id):
return weblab.core.server.get_user_information()
session_id = (request.cookies.get('weblabsessionid') or '').split('.')[0]
if session_id:
try:
with weblab_api(self.core_server, session_id = session_id):
return weblab.core.server.get_user_information()
except SessionNotFoundError:
pass
return None
class VoterEventAdmin(AdminModelView):
column_display_pk = True
form_columns = ['user_id', 'is_voter', 'timestamp']
column_list = ['id', 'user_id', 'user.nickname', 'is_voter', 'timestamp']
column_default_sort = ('timestamp', True)
class VoterApplicationAdmin(AdminModelView):
column_display_pk = True
column_list = ['id', 'user_id', 'user.nickname', 'primary_team', 'other_teams', 'consumption_tags']
class ConsumptionTagAdmin(AdminModelView):
column_display_pk = True
form_columns = ['id', 'text']
column_list = ['id', 'text']
# Create admin
admin = Admin(name='User Poll Control Panel', index_view=MyAdminIndexView(endpoint="admin"))
admin.init_app(app)
admin.add_view(UserAdmin(User, db.session))
admin.add_view(TeamAdmin(Team, db.session))
admin.add_view(PollAdmin(Poll, db.session))
admin.add_view(BallotAdmin(Ballot, db.session))
admin.add_view(VoteAdmin(Vote, db.session))
admin.add_view(VoterEventAdmin(VoterEvent, db.session))
admin.add_view(VoterApplicationAdmin(VoterApplication, db.session))
admin.add_view(ConsumptionTagAdmin(ConsumptionTag, db.session))
