def run_admin(host, port, db, password, listen):
conn = redis.Redis(host, int(port or 6379), int(db or 0), password)
tiger = TaskTiger(setup_structlog=True, connection=conn)
app = Flask(__name__)
admin = Admin(app, url='/')
admin.add_view(TaskTigerView(tiger, name='TaskTiger', endpoint='tasktiger'))
app.run(debug=True, port=int(listen or 5000))
def test_admin(db, app):
"""Test flask-admin interace."""
admin = Admin(app, name="AdminExt")
# Register models in admin
for adminview in (sip_adminview, sipfile_adminview, recordsip_adminview):
assert 'model' in adminview
assert 'modelview' in adminview
admin_kwargs = dict(adminview)
model = admin_kwargs.pop('model')
modelview = admin_kwargs.pop('modelview')
admin.add_view(modelview(model, db.session, **admin_kwargs))
# Check if generated admin menu contains the correct items
menu_items = {str(item.name): item for item in admin.menu()}
# PIDStore should be a category
assert 'Records' in menu_items
assert menu_items['Records'].is_category()
assert isinstance(menu_items['Records'], menu.MenuCategory)
# Items in PIDStore menu should be the modelviews
submenu_items = {str(item.name): item for item in
menu_items['Records'].get_children()}
assert 'SIP' in submenu_items
assert 'RecordSIP' in submenu_items
assert 'SIPFile' in submenu_items
assert isinstance(submenu_items['SIP'], menu.MenuView)
assert isinstance(submenu_items['RecordSIP'], menu.MenuView)
assert isinstance(submenu_items['SIPFile'], menu.MenuView)
def test_admin(app):
"""Test flask-admin interace."""
admin = Admin(app, name="Test")
assert 'model' in record_adminview
assert 'modelview' in record_adminview
# Register both models in admin
model = record_adminview.pop('model')
view = record_adminview.pop('modelview')
admin.add_view(view(model, db.session, **record_adminview))
# Check if generated admin menu contains the correct items
menu_items = {str(item.name): item for item in admin.menu()}
assert 'Records' in menu_items
assert menu_items['Records'].is_category()
submenu_items = {
str(item.name): item for item in menu_items['Records'].get_children()}
assert 'Record Metadata' in submenu_items
assert isinstance(submenu_items['Record Metadata'], menu.MenuView)
# Create a test record.
with app.app_context():
rec_uuid = str(uuid.uuid4())
Record.create({'title': 'test'}, id_=rec_uuid)
db.session.commit()
with app.test_request_context():
index_view_url = url_for('recordmetadata.index_view')
delete_view_url = url_for('recordmetadata.delete_view')
detail_view_url = url_for(
'recordmetadata.details_view', id=rec_uuid)
with app.test_client() as client:
# List index view and check record is there.
res = client.get(index_view_url)
assert res.status_code == 200
# Fake a problem with SQLAlchemy.
with patch('invenio_records.admin.Record') as db_mock:
db_mock.side_effect = SQLAlchemyError()
res = client.post(
delete_view_url, data={'id': rec_uuid}, follow_redirects=True)
assert res.status_code == 200
# Delete it.
res = client.post(
delete_view_url, data={'id': rec_uuid}, follow_redirects=True)
assert res.status_code == 200
# View the delete record
res = client.get(detail_view_url)
assert res.status_code == 200
assert '<pre>null</pre>' in res.get_data(as_text=True)
# Delete it again
res = client.post(
delete_view_url, data={'id': rec_uuid}, follow_redirects=True)
assert res.status_code == 200
def create_app(settings_override=None):
"""Return the PyGotham admin application.
:param settings_override: a ``dict`` of settings to override.
"""
app = factory.create_app(__name__, __path__, settings_override)
app.jinja_env.filters['rst'] = filters.rst_to_html
# Because the admin is being wrapped inside an app, the url needs to
# be overridden to use / instead of the default of /admin/. One of
# the side effects of doing this is that the static assets won't
# serve correctly without overriding static_url_path as well.
admin = Admin(
app, name='PyGotham',
static_url_path='/admin',
index_view=HomeView(endpoint='', url='/'),
)
# Iterate through all the modules of the current package. For each
# module, check the public API for any instances of types that can
# be added to the Flask-Admin menu and register them.
for _, name, _ in pkgutil.iter_modules(__path__):
module = importlib.import_module('{}.{}'.format(__name__, name))
for attr in dir(module):
view = getattr(module, attr)
if isinstance(view, ModelView):
admin.add_view(view)
elif isinstance(view, MenuLink):
admin.add_link(view)
return app
def create_admin(app):
admin = Admin(app)
admin.add_view(ModelView(Envelope, db.session))
admin.add_view(ModelView(Budget, db.session))
return admin
def test_admin():
"""Test flask-admin interace."""
app = Flask('testapp')
FlaskCLI(app)
InvenioDB(app)
InvenioPIDStore(app)
admin = Admin(app, name="AdminExt")
pid_kwargs = dict(pid_adminview)
assert 'model' in pid_adminview
assert 'modelview' in pid_adminview
# Register both models in admin
pid_model = pid_kwargs.pop('model')
pid_mv = pid_kwargs.pop('modelview')
admin.add_view(pid_mv(pid_model, db.session, **pid_kwargs))
# Check if generated admin menu contains the correct items
menu_items = {str(item.name): item for item in admin.menu()}
# PIDStore should be a category
assert 'Records' in menu_items
assert menu_items['Records'].is_category()
assert isinstance(menu_items['Records'], menu.MenuCategory)
# Items in PIDStore menu should be the modelviews
submenu_items = {str(item.name): item for item in
menu_items['Records'].get_children()}
assert 'Persistent Identifier' in submenu_items
assert isinstance(submenu_items['Persistent Identifier'], menu.MenuView)
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_admin(app=None):
admin = Admin(app, name='CleanBlogAdmin',
index_view=MyIndexView(),
base_template='admin/my_master.html')
#admin.add_view(MyView(name='Hello'))
admin.add_view(UserView(User))
admin.add_view(PostView(Post))
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 test_admin(app):
"""Test flask-admin interace."""
InvenioOAuthClient(app)
assert isinstance(remote_account_adminview, dict)
assert isinstance(remote_token_adminview, dict)
assert 'model' in remote_account_adminview
assert 'modelview' in remote_account_adminview
assert 'model' in remote_token_adminview
assert 'modelview' in remote_token_adminview
admin = Admin(app, name='Test')
user_model = remote_account_adminview.pop('model')
user_view = remote_account_adminview.pop('modelview')
admin.add_view(user_view(user_model, db.session,
**remote_account_adminview))
with app.app_context():
# create user and save url for testing
request_url = url_for('remoteaccount.index_view')
with app.app_context():
with app.test_client() as client:
res = client.get(
request_url,
follow_redirects=True
)
assert res.status_code == 200
assert 'Extra Data' in str(res.get_data())
assert 'Tokens' in str(res.get_data())
def test_admin(app, db):
"""Test admin interface."""
assert isinstance(ca, dict)
assert isinstance(ta, dict)
assert 'model' in ca
assert 'modelview' in ca
assert 'model' in ta
assert 'modelview' in ta
# Create admin
admin = Admin(app, name='Example: Sequence Generator')
# Add views
admin.add_view(ta['modelview'](ta['model'], db.session))
admin.add_view(ca['modelview'](ca['model'], db.session))
with app.app_context():
# Create test data
seq = Sequence(Template.create('ID', 'File {counter}'))
assert seq.next() == 'File 0'
assert seq.next() == 'File 1'
assert seq.next() == 'File 2'
db.session.commit()
with app.test_request_context():
request_url = url_for('counter.reset_view')
with app.test_client() as client:
# Reset counter
client.post(request_url,
data={'start': 0, 'rowid': 'File {counter}'},
follow_redirects=False)
# Assert that reset was successful
assert seq.next() == 'File 0'
def register(app):
"""
Register blueprints
:param app: a flask app instance
:return:
"""
app.register_blueprint(home_routes)
admin = Admin(app, name='Open Event API', template_mode='bootstrap3', index_view=MyAdminIndexView(),
base_template='admin_base.html')
# Get all the models in the db, all models should have a explicit __tablename__
classes, models, table_names = [], [], []
# noinspection PyProtectedMember
for class_ in list(db.Model._decl_class_registry.values()):
try:
table_names.append(class_.__tablename__)
classes.append(class_)
except:
pass
for table in list(db.metadata.tables.items()):
if table[0] in table_names:
models.append(classes[table_names.index(table[0])])
for model in models:
admin.add_view(AdminModelView(model, db.session))
def init_admin():
admin = Admin(app)
admin.add_view(UserModelView(User, db.session, category='Auth'))
admin.add_view(AdminModelView(Role, db.session, category='Auth'))
admin.add_view(AdminModelView(SomeStuff, db.session))
admin.add_view(LogoutView(name='Logout', endpoint='logout'))
admin.add_view(LoginView(name='Login', endpoint='login'))
def create_app(app=None, config_file=None):
if not app:
app = Flask(__name__, template_folder="views")
# Config files
app.config.from_pyfile("config/base.py")
if config_file:
app.config.from_pyfile("config/{}.py".format(config_file))
# Extensions
Foundation(app)
admin = Admin(app, name='Bolsa de Trabajo', template_mode='bootstrap3')
"""
CONTROLADORES
"""
# Blueprints
app.register_blueprint(frontend)
# Admin Views
admin.add_view(AdminSkillView(Skill, db.session))
admin.add_view(AdminStudentView(Student, db.session))
admin.add_view(AdminCompanyView(Company, db.session))
return app
def create_app(script_info=None):
"""Create app."""
app = Flask(__name__)
# logging
if not os.path.exists(user_data_dir):
os.makedirs(user_data_dir)
log_dir = os.path.join(user_data_dir, 'log')
if not os.path.exists(log_dir):
os.makedirs(log_dir)
peewee_logger = logging.getLogger('peewee')
peewee_logger.setLevel(logging.INFO)
chardet_logger = logging.getLogger('chardet')
chardet_logger.setLevel(logging.INFO)
default_log_file = os.path.join(log_dir, 'iqdb_tagger_server.log')
file_handler = TimedRotatingFileHandler(default_log_file, 'midnight')
file_handler.setLevel(logging.WARNING)
file_handler.setFormatter(logging.Formatter('<%(asctime)s> <%(levelname)s> %(message)s'))
app.logger.addHandler(file_handler)
app.logger.addHandler(peewee_logger)
app.logger.addHandler(chardet_logger)
# reloader
reloader = app.config['TEMPLATES_AUTO_RELOAD'] = \
bool(os.getenv('IQDB_TAGGER_RELOADER')) or app.config['TEMPLATES_AUTO_RELOAD'] # NOQA
if reloader:
app.jinja_env.auto_reload = True
app.config['SECRET_KEY'] = os.getenv('IQDB_TAGGER_SECRET_KEY') or os.urandom(24)
app.config['WTF_CSRF_ENABLED'] = False
# debug
debug = app.config['DEBUG'] = bool(os.getenv('IQDB_TAGGER_DEBUG')) or app.config['DEBUG']
if debug:
app.config['DEBUG'] = True
app.config['LOGGER_HANDLER_POLICY'] = 'debug'
logging.basicConfig(level=logging.DEBUG)
pprint.pprint(app.config)
print('Log file: {}'.format(default_log_file))
print('script info:{}'.format(script_info))
db_path = os.getenv('IQDB_TAGGER_DB_PATH') or default_db_path
init_program()
init_db(db_path)
# app and db
app.app_context().push()
@app.shell_context_processor
def shell_context(): # pylint: disable=unused-variable
return {'app': app}
# flask-admin
app_admin = Admin(
app, name='IQDB Tagger', template_mode='bootstrap3',
index_view=views.HomeView(name='Home', template='iqdb_tagger/index.html', url='/'))
app_admin.add_view(views.MatchView())
# app_admin.add_view(ModelView(ImageMatch, category='DB'))
# app_admin.add_view(ModelView(ImageMatchRelationship, category='DB'))
# app_admin.add_view(ModelView(ImageModel, category='DB'))
# app_admin.add_view(ModelView(MatchTagRelationship, category='DB'))
# routing
app.add_url_rule('/thumb/<path:basename>', view_func=thumb)
return app
def register(self,app, options, first_registration=False):
print app
admin = Admin(app, name='blog')
for v in self.views:
admin.add_view(v)
return super(AdminBlueprint, self).register(app, options, first_registration)
class InvenioAdmin(object):
"""Invenio-Admin extension.
:param app: Flask application.
:param entry_point_group: Name of entry point group to load views/models
from.
"""
def __init__(self, app=None, anonymous=False, **kwargs):
"""InvenioAdmin extension initialization.
If `anonymous` is True, the admin views are accessible to anonymous
users and all security checks are bypassed (use for testing only).
"""
self.anonymous = anonymous
if app:
self.init_app(app, **kwargs)
def init_app(self, app, entry_point_group='invenio_admin.views',
**kwargs):
"""Flask application initialization."""
self.init_config(app)
# Create admin instance.
index_view = AdminIndexView if self.anonymous \
else ProtectedAdminIndexView
self.admin = Admin(
app,
name=app.config['ADMIN_APPNAME'],
template_mode=kwargs.get('template_mode', 'bootstrap3'),
index_view=index_view())
# Load administration interfaces defined by entry points.
if entry_point_group:
for ep in pkg_resources.iter_entry_points(group=entry_point_group):
adminview_dict = dict(ep.load())
assert 'model' in adminview_dict, \
"Admin's entrypoint dictionary must define the 'model'"
assert 'modelview' in adminview_dict, \
"Admin's entrypoint dictionary must define the 'modelview'"
model = adminview_dict.pop('model')
modelview = adminview_dict.pop('modelview')
# If not in anonymous access mode add model-based security
if not self.anonymous:
modelview = protected_adminview_factory(modelview)
self.admin.add_view(
modelview(model, db.session, **adminview_dict))
app.extensions['invenio-admin'] = self
def init_config(self, app):
"""Initialize configuration."""
# Set default configuration
for k in dir(config):
if k.startswith("ADMIN_"):
app.config.setdefault(k, getattr(config, k))
def test_admin(app):
"""Test flask-admin interace."""
InvenioAccounts(app)
assert isinstance(role_adminview, dict)
assert isinstance(user_adminview, dict)
assert 'model' in role_adminview
assert 'modelview' in role_adminview
assert 'model' in user_adminview
assert 'modelview' in user_adminview
admin = Admin(app, name="Test")
user_model = user_adminview.pop('model')
user_view = user_adminview.pop('modelview')
admin.add_view(user_view(user_model, db.session, **user_adminview))
# Test activation and deactivation
with app.app_context():
# create user and save url for testing
request_url = url_for("user.action_view")
kwargs = dict(email="*****@*****.**", active=False,
password=encrypt_password('aafaf4as5fa'))
_datastore.create_user(**kwargs)
_datastore.commit()
with app.app_context():
with app.test_client() as client:
inserted_id = _datastore.get_user('*****@*****.**').id
res = client.post(
request_url,
data={'rowid': inserted_id, 'action': 'activate'},
follow_redirects=True
)
assert res.status_code == 200
res = client.post(
request_url,
data={'rowid': inserted_id, 'action': 'inactivate'},
follow_redirects=True
)
assert res.status_code == 200
pytest.raises(ValueError, client.post, request_url,
data={'rowid': -42, 'action': 'inactivate'},
follow_redirects=True
)
pytest.raises(ValueError, client.post, request_url,
data={'rowid': -42, 'action': 'activate'},
follow_redirects=True
)
def init_admin():
# Initialize flask-security
user_datastore = SQLAlchemyUserDatastore(db, models.User, models.Role)
security = Security(app, user_datastore)
# Initialize custom admin views
admin = Admin(app, name='trevorroman.com', template_mode='bootstrap3')
admin.add_view(PostView(models.Post, db.session))
admin.add_view(UserView(models.User, db.session))
admin.add_view(TagView(models.Tag, db.session))
return admin, user_datastore
def test_admin(app):
"""Test Flask-Admin interace."""
admin = Admin(app, name='Test')
assert 'model' in set_adminview
assert 'modelview' in set_adminview
# Register both models in admin
model = set_adminview.pop('model')
view = set_adminview.pop('modelview')
admin.add_view(view(model, db.session, **set_adminview))
# Check if generated admin menu contains the correct items
menu_items = {str(item.name): item for item in admin.menu()}
assert 'OAI-PMH' in menu_items
assert menu_items['OAI-PMH'].is_category()
submenu_items = {
str(item.name): item for item in menu_items['OAI-PMH'].get_children()
}
assert 'Sets' in submenu_items
assert isinstance(submenu_items['Sets'], menu.MenuView)
# Create a test set.
with app.app_context():
test_set = OAISet(id=1,
spec='test',
name='test_name',
description='some test description',
search_pattern='test search')
db.session.add(test_set)
db.session.commit()
with app.test_request_context():
index_view_url = url_for('oaiset.index_view')
delete_view_url = url_for('oaiset.delete_view')
detail_view_url = url_for('oaiset.details_view', id=1)
with app.test_client() as client:
# List index view and check record is there.
res = client.get(index_view_url)
assert res.status_code == 200
# Deletion is forbiden.
res = client.post(
delete_view_url, data={'id': 1}, follow_redirects=True)
assert res.status_code == 200
# View the deleted record.
res = client.get(detail_view_url)
assert res.status_code == 200
assert 1 == OAISet.query.count()
def create_app(config_name):
'''Flask application factory function'''
app = Flask(__name__)
app.config.from_object(config[config_name])
config[config_name].init_app(app)
app.jinja_env.line_statement_prefix = '%'
bootstrap.init_app(app)
db.init_app(app)
app.user_datastore = PeeweeUserDatastore(db, User, Role, UserRoles)
security = Security(app, app.user_datastore)
# Setup blueprints
from .public import public as public_blueprint
app.register_blueprint(public_blueprint)
from .member import member as member_blueprint
app.register_blueprint(member_blueprint)
from .board import board as board_blueprint
app.register_blueprint(board_blueprint)
from .invoice import invoice as invoice_blueprint
app.register_blueprint(invoice_blueprint)
# Setup flask-admin
from .admin.controller import MyModelView, MyAdminView
admin = Admin(app, 'Admin Panel',
template_mode='bootstrap3',
index_view=MyAdminView(
name='Admin Index',
template='admin/index.html',
url='/admin'))
admin.add_view(MyModelView(User))
admin.add_view(MyModelView(Role))
admin.add_view(MyModelView(UserRoles))
# define a context processor for merging flask-admin's template context
# into the flask-security views.
@security.context_processor
def security_context_processor():
return dict(
admin_base_template=admin.base_template,
admin_view=admin.index_view,
h=admin_helpers
)
return app
def init_app(app):
app.register_blueprint(bp)
app.json_encoder = h.JSONEncoder
processor_admin = Admin(app,
url='/processor_admin',
endpoint='/processor_admin',
name='Processor Portal',
base_template='processor/admin/base.html',
template_mode='bootstrap3')
processor_admin.add_view(ChargeView(
Charge, db.session, endpoint='charges'))
return app
def init_app(app):
admin = Admin(
app, name='Dashboard',
template_mode='bootstrap3',
endpoint='admin',
index_view=IndexView(),
)
admin.add_view(UserModelView(User, db.session))
admin.add_view(CafeModelView(Cafe, db.session))
admin.add_view(TopicModelView(Topic, db.session))
if app.config.get('ADMIN_STATIC_URL'):
app.jinja_env.globals['url_for'] = url_for
def initialize(flask_app, flask_db):
"""
Define the admin views
"""
admin = Admin(flask_app, name="pwts", template_mode="bootstrap3")
admin.add_view(ModelView(Area, flask_db.session))
admin.add_view(ModelView(Category, flask_db.session))
admin.add_view(ModelView(Priority, flask_db.session))
admin.add_view(ModelView(Size, flask_db.session))
admin.add_view(ModelView(Status, flask_db.session))
admin.add_view(ModelView(Type, flask_db.session))
admin.add_view(ModelView(User, flask_db.session))
def create_admin():
app = current_app._get_current_object()
admin = Admin(app, "AtomicPress", index_view=HomeView(name='Home'))
admin.add_view(ModelView(models.Blog, db.session, category="Blog"))
admin.add_view(ModelView(models.Author, db.session, category="Blog"))
admin.add_view(PostView(models.Post, db.session, category="Post"))
admin.add_view(ModelView(models.Tag, db.session, category="Post"))
admin.add_view(ModelView(models.Category, db.session, category="Post"))
admin.add_view(FileAdmin(app.config["UPLOADS_PATH"],
app.config["UPLOADS_URL"],
name='Upload files'))
def create_app():
app = Flask(__name__)
app.config.from_object(Config)
db.init_app(app)
security = Security(app, user_datastore)
admin = Admin(app)
admin.add_view(ActivityAdmin(Activity, db.session))
admin.add_view(UserAdmin(User, db.session))
admin.add_view(PageAdmin(Page, db.session))
# import ipdb; ipdb.set_trace()
app.register_blueprint(content_bp)
app.register_blueprint(user_bp)
app.add_url_rule('/', 'index', index)
return app
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 create_app(settings_override=None):
"""Returns an Admin application instance."""
# Create and extend a minimal application
app = framework.create_app(__name__, __path__, settings_override, security_register_blueprint=False)
from .invite_view import InviteView
from .user_view import UserView
#Init the flask-admin
admin = Admin(app, name='FogMine Admin', url='/', index_view=MyAdminIndexView(url='/'), template_mode='bootstrap3', base_template='admin/my_master.html')
admin.add_view(UserView(db.session))
admin.add_view(InviteView(db.session))
return app
def create_app():
app = Flask(__name__)
app.config.from_object('config')
db.init_app(app)
Migrate(app, db)
# Register the blueprint applications
from .v1 import api as api_blueprint
app.register_blueprint(api_blueprint, url_prefix='/v1')
# Flask-Admin
admin = Admin(app, name='研究時間記録', template_mode='bootstrap3')
admin.add_view(UserAdmin(User, db.session, name='ユーザ'))
admin.add_view(RecordAdmin(Record, db.session, name='研究記録'))
# Define special routes
@app.after_request
def after_request(response):
for query in get_debug_queries():
if query.duration >= app.config['SLOW_DB_QUERY_TIME']:
app.logger.warning(
'Slow query: %s\nParameters: %s\n'
'Duration: %fs\nContext: %s\n'
% (query.statement, query.parameters,
query.duration, query.context)
)
return response
@app.errorhandler(404)
def page_not_found(e):
"""Return a custom 404 error."""
return jsonify(
error='Not found',
message='Sorry, Nothing at this api.',
status=404
)
@app.errorhandler(500)
def page_not_found(e):
"""Return a custom 500 error."""
return jsonify(
error='Internal server error',
message='Sorry, unexpected error: {}'.format(e),
status=500
)
return app
def admin_view(app):
"""Admin view fixture."""
assert isinstance(role_adminview, dict)
assert isinstance(user_adminview, dict)
assert 'model' in role_adminview
assert 'modelview' in role_adminview
assert 'model' in user_adminview
assert 'modelview' in user_adminview
admin = Admin(app, name="Test")
user_adminview_copy = dict(user_adminview)
user_model = user_adminview_copy.pop('model')
user_view = user_adminview_copy.pop('modelview')
admin.add_view(user_view(user_model, db.session, **user_adminview_copy))
# ---------------------------------------------------------------------------------
# Classes Databases
# -------------------------------------------------------------------------------*/
class User(UserMixin, db.Model):
__tablename__ = 'User'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(15), unique=True)
email = db.Column(db.String(50), unique=True)
password = db.Column(db.String(80))
setup = db.Column(db.Boolean())
activated = db.Column(db.Boolean())
admin.add_view(ModelView(User,
db.session)) # create User view for current session
@login_manager.user_loader
def load_user(user_id):
return User.query.get(int(user_id))
class Match(db.Model):
__tablename__ = 'Match'
username = db.Column(db.String(15), primary_key=True, unique=True)
view_count = db.Column(db.Integer())
image = db.Column(db.String(120))
name = db.Column(db.String(20))
gender = db.Column(db.String(20))
pref_gender = db.Column(db.String(20))
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(CouponAdmin(Coupon, db.session))
admin.add_view(ManualSubscriptionAdmin(ManualSubscription, db.session))
admin.add_view(ClientAdmin(Client, db.session))
admin.add_view(ReferralAdmin(Referral, db.session))
admin.add_view(PayoutAdmin(Payout, db.session))
app.config['MAIL_SERVER'] = 'smtp.gmail.com'
app.config['MAIL_PORT'] = 465
app.config['MAIL_USE_SSL'] = True
app.config['MAIL_USERNAME'] = '******'
app.config['MAIL_PASSWORD'] = '******'
flask_mail = Mail(app)
# set up flask-Admin
flask_admin = Admin(app, name='jdiandian', template_mode='bootstrap3')
class CheckModelView(ModelView):
def is_accessible(self):
if session.get('admin_in',False):
return True
else:
return False
flask_admin.add_view(CheckModelView(User, db_session))
flask_admin.add_view(CheckModelView(Tracking, db_session))
flask_admin.add_view(CheckModelView(Subscribe, db_session))
flask_admin.add_view(CheckModelView(Article, db_session))
flask_admin.add_view(CheckModelView(ArticleBody, db_session))
# set up flask-uploads
app.config['UPLOADED_AVATARS_DEST'] = '/var/www/FlaskApp/jdd/static/uploads/avatars/'
app.config['UPLOADED_DONATES_DEST'] = '/var/www/FlaskApp/jdd/static/uploads/donates/'
app.config['UPLOADS_DEFAULT_DEST'] = '/var/www/FlaskApp/jdd/static/uploads/'
# there are DEFAUTL(text.doc.data,images), ALL, TEXT, IMAGES, AUDIO, DOCUMENTS, DATA,
# SCRIPTS, ARCHIVES, EXECUTABLES for choice
avatars = UploadSet('avatars', IMAGES)
donates = UploadSet('donates',IMAGES)
configure_uploads(app, avatars)
def register_admin(app):
admin = Admin(app, name='admin', template_mode='bootstrap3')
admin.add_view(ModelView(User, db.session))
from auction import Auction, db
from flask import redirect, render_template, url_for
from flask_admin import Admin
from flask_admin.contrib.sqla import ModelView
from flask_bootstrap import Bootstrap
from flask_user import UserManager, login_required
from model import User
Bootstrap(Auction)
admin = Admin(Auction, template_mode='bootstrap3')
user_manager = UserManager(Auction, db, User)
admin.add_view(ModelView(User, db.session))
@Auction.route('/')
def plain():
return "Hello World"
@Auction.route('/dashboard')
@login_required
def dashboard():
"""
Entry point to the application
"""
return render_template('dashboard.html')
# Add custom filter and standard FilterEqual to ModelView
class UserAdmin(sqla.ModelView):
# each filter in the list is a filter operation (equals, not equals, etc)
# filters with the same name will appear as operations under the same filter
column_filters = [
FilterEqual(column=User.last_name, name="Last Name"),
FilterLastNameBrown(column=User.last_name,
name="Last Name",
options=(("1", "Yes"), ("0", "No"))),
]
admin = Admin(app, template_mode="bootstrap3")
admin.add_view(UserAdmin(User, db.session))
def build_sample_db():
db.drop_all()
db.create_all()
user_obj1 = User("Paul", "Brown", "pbrown", "*****@*****.**")
user_obj2 = User("Luke", "Brown", "lbrown", "*****@*****.**")
user_obj3 = User("Serge", "Koval", "skoval", "*****@*****.**")
db.session.add_all([user_obj1, user_obj2, user_obj3])
db.session.commit()
if __name__ == "__main__":
build_sample_db()
class OrdersModelView(ModelView):
column_list = [
'ship_name', 'order_date', 'ship_address', 'notes',
'employees.first_name'
]
can_view_details = True
class ProductsModelView(ModelView):
column_list = [
'product_code', 'product_name', 'quantity_per_unit', 'standard_cost'
]
can_view_details = True
class PurchaseOrdersModelView(ModelView):
column_list = ['id', 'submitted_date', 'status_id', 'notes', 'approved_by']
can_view_details = True
# Administration Site
admin = Admin(app, name='Web Office', template_mode='bootstrap3')
admin.add_view(CustomersModelView(Customers, session, 'Clientes'))
admin.add_view(EmployeesModelView(Employees, session, 'Empleados'))
admin.add_view(OrdersModelView(Orders, session, 'Ordenes'))
admin.add_view(ProductsModelView(Products, session, 'Productos'))
admin.add_view(ModelView(Privileges, session, 'Provilegios'))
admin.add_view(
PurchaseOrdersModelView(PurchaseOrders, session, 'Ordenes Realizadas'))
def init_admin(app):
db.init_app(app)
admin = Admin(app, name='flaskr-revisited', template_mode='bootstrap3')
admin.add_view(ModelView(User, db.session))
admin.add_view(ModelView(Post, db.session))
app.cli.add_command(init_db_command)
@app.route('/',methods=['GET','POST'])
def process():
if request.method=='POST':
conn=sqlite3.connect('new_database.db')
c=conn.cursor()
userDetails=request.form
main=userDetails['processname']
#num=userDetails['totalpro']
mainp=Process(process_name=main)
db.session.add(mainp)
db.session.commit()
conn.commit()
c.close()
return 'success'
return render_template('process.html')
def subprocess():
if request.method=='POST':
conn=sqlite3.connect('abb.db')
c=conn.cursor()
userDetails=request.form
'''
admin.add_view(Processview(Process, db.session))
admin.add_view(Subprocessview(Subprocess, db.session))
admin.add_view(Employeeview(Employee, db.session))
admin.add_view(ModelView(Attribute, db.session))
if __name__ == '__main__':
app.run(debug=True)
'is_custom', 'type')
#inline_models=(Category.id)
form_excluded_columns = [
'children',
]
admin = Admin(app,
name=app.config['SITE_NAME'] + u'管理后台',
template_mode='bootstrap3')
# Setup Flask-Security
user_datastore = SQLAlchemyUserDatastore(db, User, Role)
security = Security(app, user_datastore)
# define a context processor for merging flask-admin's template context into the
# flask-security views.
@security.context_processor
def security_context_processor():
return dict(admin_base_template=admin.base_template,
admin_view=admin.index_view,
h=admin_helpers,
get_url=url_for)
admin.add_view(UserModelView(User, db.session, u'用户管理'))
admin.add_view(DatasetModelView(Dataset, db.session, u'数据集管理'))
admin.add_view(RoleModelView(Role, db.session, u'权限管理'))
admin.add_view(CategoryView(Category, db.session, u'分类管理'))
def on_model_change(self, form, model, is_created):
model.generate_slug()
return super(BaseModelView,
self).on_model_change(form, model, is_created)
class AdminView(AdminMixin, ModelView):
pass
class HomeAdminView(AdminMixin, AdminIndexView):
pass
class PostAdminView(AdminMixin, BaseModelView):
form_columns = ['title', 'body', 'tags']
class TagAdminView(AdminMixin, BaseModelView):
form_columns = ['name', 'posts']
admin = Admin(app, 'FlaskApp', url='/', index_view=HomeAdminView(name='Home'))
admin.add_view(PostAdminView(Post, db.session))
admin.add_view(TagAdminView(Tag, db.session))
### Flask security ###
user_datastore = SQLAlchemyUserDatastore(db, User, Role)
security = Security(app, user_datastore)
if not model.photopath:
return ''
return Markup('<img src="%s">' % url_for('static',
filename=form.thumbgen_filename(model.photopath)))
column_formatters = {
'photopath': _list_thumbnail
}
# Alternative way to contribute field is to override it completely.
# In this case, Flask-Admin won't attempt to merge various parameters for the field.
form_extra_fields = {
'photopath': form.ImageUploadField('Image',
base_path=file_path,
thumbnail_size=(100, 100, True))
}
admin = Admin(app, name='学生管理系统', template_mode='bootstrap3')
# Add administrative views here
admin.add_view(ImageView(Student, db.session,name=u'学生管理'))
if __name__ == '__main__':
app_dir = op.realpath(os.path.dirname(__file__))
database_path = op.join(app_dir, app.config['DATABASE_FILE'])
if not os.path.exists(database_path):
build_sample_db()
app.run(host='0.0.0.0', port=5010, debug=True)
from flask_admin import Admin from flask_admin.contrib.sqla import ModelView from app.models import Employee, Post, db admin = Admin() admin.add_view(ModelView(Post, db.session)) admin.add_view(ModelView(Employee, db.session))
def test_modal_edit(self):
# bootstrap 2 - test edit_modal
app_bs2 = Flask(__name__)
admin_bs2 = Admin(app_bs2, template_mode="bootstrap2")
fileadmin_class = self.fileadmin_class()
fileadmin_args, fileadmin_kwargs = self.fileadmin_args()
class EditModalOn(fileadmin_class):
edit_modal = True
editable_extensions = ('txt', )
class EditModalOff(fileadmin_class):
edit_modal = False
editable_extensions = ('txt', )
on_view_kwargs = dict(fileadmin_kwargs)
on_view_kwargs.setdefault('endpoint', 'edit_modal_on')
edit_modal_on = EditModalOn(*fileadmin_args, **on_view_kwargs)
off_view_kwargs = dict(fileadmin_kwargs)
off_view_kwargs.setdefault('endpoint', 'edit_modal_off')
edit_modal_off = EditModalOff(*fileadmin_args, **off_view_kwargs)
admin_bs2.add_view(edit_modal_on)
admin_bs2.add_view(edit_modal_off)
client_bs2 = app_bs2.test_client()
# bootstrap 2 - ensure modal window is added when edit_modal is
# enabled
rv = client_bs2.get('/admin/edit_modal_on/')
eq_(rv.status_code, 200)
data = rv.data.decode('utf-8')
ok_('fa_modal_window' in data)
# bootstrap 2 - test edit modal disabled
rv = client_bs2.get('/admin/edit_modal_off/')
eq_(rv.status_code, 200)
data = rv.data.decode('utf-8')
ok_('fa_modal_window' not in data)
# bootstrap 3
app_bs3 = Flask(__name__)
admin_bs3 = Admin(app_bs3, template_mode="bootstrap3")
admin_bs3.add_view(edit_modal_on)
admin_bs3.add_view(edit_modal_off)
client_bs3 = app_bs3.test_client()
# bootstrap 3 - ensure modal window is added when edit_modal is
# enabled
rv = client_bs3.get('/admin/edit_modal_on/')
eq_(rv.status_code, 200)
data = rv.data.decode('utf-8')
ok_('fa_modal_window' in data)
# bootstrap 3 - test modal disabled
rv = client_bs3.get('/admin/edit_modal_off/')
eq_(rv.status_code, 200)
data = rv.data.decode('utf-8')
ok_('fa_modal_window' not in data)
flask_app.config['DEBUG'] = True
#swagger config
flask_app.config['SWAGGER_UI_DOC_EXPANSION'] = 'list'
flask_app.config['RESTPLUS_VALIDATE'] = True
flask_app.config['RESTPLUS_MASK_SWAGGER'] = False
blueprint = Blueprint('api', __name__, url_prefix='/api')
api.init_app(blueprint)
#api.add_namespace(blog_posts_namespace)
flask_app.register_blueprint(blueprint)
#---add blueprint ---> bashe khob hala :)
import time
time.sleep(5)
db.app = flask_app
db.init_app(flask_app)
db.create_all()
init_hero()
admin = Admin(flask_app)
admin.add_view(ModelView(User, db.session))
admin.add_view(ModelView(Player_Hero, db.session))
admin.add_view(ModelView(Hero, db.session))
if __name__ == '__main__':
flask_app.run(host='0.0.0.0', port=5008)
created_at = db.Column(db.Date, default=dt.datetime.utcnow)
@property
def serialize(self):
return {
'id': self.id,
'settle_date': str(self.settle_date),
'currency': self.currency,
'symbol': self.symbol,
'type': self.type,
'price': str(self.price),
'quantity': str(self.quantity)
}
admin.add_view(ModelView(Activity, db.session))
def allowed_file(filename):
return '.' in filename and filename.rsplit(
'.', 1)[1].lower() in ALLOWED_EXTENSIONS
@app.route('/', methods=['POST'])
def upload_file():
if request.method == 'POST':
statement = AccountStatement()
app.logger.error(request.files)
files = request.files.getlist("files[]")
app.logger.error(f"count={len(files)}")
if len(files) < 1:
#coding=utf-8
import os
from flask_script import Manager
from app import create_app
from flask_admin import Admin
from app.admin.views import Setting
from flask_babelex import Babel
from app.models import User,Interviewer,Record
app = create_app(os.getenv('FLASK_CONFIG') or 'default')
manager = Manager(app)
admin = Admin(app,name='后台管理',template_mode='bootstrap3')
babel = Babel(app)
def create_all_tables():
models = [User,Interviewer,Record]
for model in models:
model.create_table(fail_silently=True)
from app.admin.modelviews import UserAdmin,InterAdmin,RecordAdmin
if __name__=='__main__':
create_all_tables()
admin.add_view(Setting(name='设置', url='/admin/settings'))
admin.add_view(UserAdmin(User,name='成员管理'))
admin.add_view(InterAdmin(Interviewer,name='面试者管理'))
admin.add_view(RecordAdmin(Record,name='面试记录管理'))
manager.run()
def test_modal_edit():
# bootstrap 2 - test edit_modal
app_bs2 = Flask(__name__)
admin_bs2 = Admin(app_bs2, template_mode="bootstrap2")
edit_modal_on = MockModelView(Model,
edit_modal=True,
endpoint="edit_modal_on")
edit_modal_off = MockModelView(Model,
edit_modal=False,
endpoint="edit_modal_off")
create_modal_on = MockModelView(Model,
create_modal=True,
endpoint="create_modal_on")
create_modal_off = MockModelView(Model,
create_modal=False,
endpoint="create_modal_off")
admin_bs2.add_view(edit_modal_on)
admin_bs2.add_view(edit_modal_off)
admin_bs2.add_view(create_modal_on)
admin_bs2.add_view(create_modal_off)
client_bs2 = app_bs2.test_client()
# bootstrap 2 - ensure modal window is added when edit_modal is enabled
rv = client_bs2.get('/admin/edit_modal_on/')
eq_(rv.status_code, 200)
data = rv.data.decode('utf-8')
ok_('fa_modal_window' in data)
# bootstrap 2 - test edit modal disabled
rv = client_bs2.get('/admin/edit_modal_off/')
eq_(rv.status_code, 200)
data = rv.data.decode('utf-8')
ok_('fa_modal_window' not in data)
# bootstrap 2 - ensure modal window is added when create_modal is enabled
rv = client_bs2.get('/admin/create_modal_on/')
eq_(rv.status_code, 200)
data = rv.data.decode('utf-8')
ok_('fa_modal_window' in data)
# bootstrap 2 - test create modal disabled
rv = client_bs2.get('/admin/create_modal_off/')
eq_(rv.status_code, 200)
data = rv.data.decode('utf-8')
ok_('fa_modal_window' not in data)
# bootstrap 3
app_bs3 = Flask(__name__)
admin_bs3 = Admin(app_bs3, template_mode="bootstrap3")
admin_bs3.add_view(edit_modal_on)
admin_bs3.add_view(edit_modal_off)
admin_bs3.add_view(create_modal_on)
admin_bs3.add_view(create_modal_off)
client_bs3 = app_bs3.test_client()
# bootstrap 3 - ensure modal window is added when edit_modal is enabled
rv = client_bs3.get('/admin/edit_modal_on/')
eq_(rv.status_code, 200)
data = rv.data.decode('utf-8')
ok_('fa_modal_window' in data)
# bootstrap 3 - test modal disabled
rv = client_bs3.get('/admin/edit_modal_off/')
eq_(rv.status_code, 200)
data = rv.data.decode('utf-8')
ok_('fa_modal_window' not in data)
# bootstrap 3 - ensure modal window is added when edit_modal is enabled
rv = client_bs3.get('/admin/create_modal_on/')
eq_(rv.status_code, 200)
data = rv.data.decode('utf-8')
ok_('fa_modal_window' in data)
# bootstrap 3 - test modal disabled
rv = client_bs3.get('/admin/create_modal_off/')
eq_(rv.status_code, 200)
data = rv.data.decode('utf-8')
ok_('fa_modal_window' not in data)
form_edit_rules = ['user_id', 'username', 'user_type']
form_excluded_columns = ['user_type']
def create_model(self, form):
form.password.data = bc.generate_password_hash(form.password.data)
super().create_model(form)
class VetView(UserView):
column_exclude_list = UserView.column_exclude_list[:].append('user_type')
column_list = ['user_id', 'username', 'supervisee', 'field']
class AssistantView(UserView):
column_exclude_list = UserView.column_exclude_list[:].append('user_type')
class SecretaryView(UserView):
column_exclude_list = UserView.column_exclude_list[:].append('user_type')
admin = Administrator(app, index_view=AdminView())
admin.add_view(UserView(User, db.session))
admin.add_view(VetView(Vet, db.session))
admin.add_view(AssistantView(Assistant, db.session))
admin.add_view(SecretaryView(Secretary, db.session))
for name, obj in inspect.getmembers(dmodels, inspect.isclass):
if name != 'datetime':
admin.add_view(ModelView(obj, db.session))
def create_app(conf_name):
app = Flask(__name__, instance_relative_config=True)
app.config.from_object(app_config[conf_name])
app.config.from_pyfile('config.py')
@app.errorhandler(404)
def page_not_found(e):
return render_template('404.html'), 404
db.init_app(app)
# @app.route('/')
# def hello_world():
# conf_var = app.config
# return render_template('index.html',conf=conf_var)
migrate = Migrate(app, db)
from app import models
#### Admin
class AdminMixin:
def is_accessible(self):
# return current_user.has_role('admin')
return True
def inaccessible_callback(self, name, **kwargs):
return redirect(url_for('security.login', next=request.url))
class BaseModelView(ModelView):
def on_model_change(self, form, model, is_created):
model.generate_slug()
return super(BaseModelView, self).on_model_change(form, model, is_created)
class PostAdminView(AdminMixin,BaseModelView):
# ограничение количества отображаемых аттрибутов
form_columns = ['title', 'body', 'tags']
class TagAdminView(AdminMixin,BaseModelView):
form_columns = ['name']
class HomeAdminView(AdminMixin, AdminIndexView):
pass
admin = Admin(app, 'FlaskApp', url='/',index_view=HomeAdminView(name='Home'))
admin.add_view(PostAdminView(models.Post,db.session))
admin.add_view(TagAdminView(models.Tag,db.session))
### Flask Security
user_datastore = SQLAlchemyUserDatastore(db, models.User, models.Role)
security = Security(app, user_datastore)
from .home import home as home_blueprint
app.register_blueprint(home_blueprint)
from .posts import posts as posts_blueprint
app.register_blueprint(posts_blueprint, url_prefix='/blog')
return app
def symptoms(self):
mysymptoms = list(self.disease_symptoms.split(','))
#print mysymptoms
return mysymptoms
def cure(self):
mycure = list(self.disease_cure.split(','))
return mycure
#def __init__(self, disease_name, cure, *symptoms):
# self.disease_name = disease_name
# self.disease_symptoms = str(symptoms)
# self.disease_cure = cure
admin.add_view(ModelView(User, db.session))
admin.add_view(ModelView(Query, db.session))
admin.add_view(ModelView(Diseases, db.session))
admin.add_view(ModelView(Issue, db.session))
admin.add_view(ModelView(Message, db.session))
@app.errorhandler(404)
def page_not_found(e):
return render_template('404.html'), 404
@app.errorhandler(500)
def internal_server_error(e):
return render_template('500.html'), 500
from flask import Flask from flask_migrate import Migrate from restoran.config import Config from restoran.models import db from flask_admin import Admin from flask_admin.contrib.sqla import ModelView app = Flask(__name__) app.config.from_object(Config) db.init_app(app) migrate = Migrate(app, db) from restoran.views import * admin = Admin(app) admin.add_view(MyUserView(User, db.session)) admin.add_view(MyUserView(Meal, db.session)) admin.add_view(MyUserView(Category, db.session)) admin.add_view(MyUserView(Order, db.session))
subtitle = db.Column(db.String(50))
author = db.Column(db.String(20))
date_posted = db.Column(db.DateTime)
content = db.Column(db.Text)
def __unicode_(self):
return self.name
class MyAdminIndexView(AdminIndexView):
def is_accessible(self):
return current_user.is_authenticated
admin = Admin(app, index_view=MyAdminIndexView())
admin.add_view(ModelView(Blogpost, db.session))
@app.route('/')
def index():
posts = Blogpost.query.order_by(Blogpost.date_posted.desc()).limit(3).all()
return render_template('index.html', posts=posts)
@app.route('/olderposts')
def olderposts():
posts = Blogpost.query.order_by(Blogpost.date_posted.desc()).all()
return render_template('olderposts.html', posts=posts)
def create_app(config_class=Config):
app = Flask(__name__)
app.config.from_object(config_class)
db.init_app(app)
migrate.init_app(app, db, render_as_batch=True)
login.init_app(app)
mail.init_app(app)
bootstrap.init_app(app)
moment.init_app(app)
babel.init_app(app)
csrf.init_app(app)
admin = Admin()
admin.init_app(app)
socketio.init_app(app, cors_allowed_origins='*')
admin.add_view(AdminView(models.User, db.session))
admin.add_view(AdminView(models.Post, db.session))
admin.add_view(AdminView(models.Test, db.session))
from app.errors import bp as errors_bp
app.register_blueprint(errors_bp)
from app.auth import bp as auth_bp
app.register_blueprint(auth_bp, url_prefix='/auth')
from app.main import bp as main_bp
app.register_blueprint(main_bp)
from app.mice import bp as mice_bp
app.register_blueprint(mice_bp, url_prefix='/mice')
from app.data import bp as data_bp
app.register_blueprint(data_bp, url_prefix='/data')
if not app.debug and not app.testing:
if app.config['MAIL_SERVER']:
auth = None
if app.config['MAIL_USERNAME'] or app.config['MAIL_PASSWORD']:
auth = (app.config['MAIL_USERNAME'],
app.config['MAIL_PASSWORD'])
secure = None
if app.config['MAIL_USE_TLS']:
secure = ()
mail_handler = SMTPHandler(
mailhost=(app.config['MAIL_SERVER'], app.config['MAIL_PORT']),
fromaddr='no-reply@' + app.config['MAIL_SERVER'],
toaddrs=app.config['ADMINS'],
subject='Match Failure',
credentials=auth,
secure=secure)
mail_handler.setLevel(logging.ERROR)
app.logger.addHandler(mail_handler)
if app.config['LOG_TO_STDOUT']:
stream_handler = logging.StreamHandler()
stream_handler.setLevel(logging.INFO)
app.logger.addHandler(stream_handler)
else:
if not os.path.exists('logs'):
os.mkdir('logs')
file_handler = RotatingFileHandler('logs/match.log',
maxBytes=10240,
backupCount=10)
file_handler.setFormatter(
logging.Formatter('%(asctime)s %(levelname)s: %(message)s '
'[in %(pathname)s:%(lineno)d]'))
file_handler.setLevel(logging.INFO)
app.logger.addHandler(file_handler)
app.logger.setLevel(logging.INFO)
app.logger.info('Match startup')
with app.app_context():
if db.engine.url.drivername == 'sqlite':
migrate.init_app(app, db, render_as_batch=True)
else:
migrate.init_app(app, db)
return app
form_columns = ['cid', 'name', 'students', 'professor']
class ProfessorAmin(sqla.ModelView):
column_display_pk = True
form_columns = ['pid', 'name', 'email', 'username', 'password']
class StudentAdmin(sqla.ModelView):
#to display primary key 3shan hwa fl framework de msh bydisplay el pk
column_display_pk = True
form_columns = ['sid', 'name']
#init el view
admin.add_view(CourseAdmin(Course, db.session))
admin.add_view(ProfessorAmin(Professor, db.session))
admin.add_view(StudentAdmin(Student, db.session))
admin.add_view(ReportAdmin(Report, db.session))
def professor_json(professor):
courses = Course.query.filter_by(professor=professor)
course_array = []
for course in courses:
course_array.append({"cid": course.cid, "name": course.name})
return jsonify({
'name': professor.name,
'pid': professor.pid,
'courses': course_array
})
from .model_view import WebSiteModelView, SiteTypeModelView, ArticleModelView, ArticleTagModelView
class AdminView(AdminIndexView):
def is_accessible(self):
return current_user and current_user.is_authenticated and current_user.is_admin
def inaccessible_callback(self, name, **kwargs):
print 111
abort(404)
admin = Admin(name='InfoSub Admin',
template_mode='bootstrap3',
index_view=AdminView())
admin.add_view(
UserModelView(User, db.session, name="User", endpoint="user_admin"))
admin.add_view(
PlanModelView(UserPlan, db.session, name="Plan", endpoint="plan_admin"))
admin.add_view(
WebSiteModelView(WebSite,
db.session,
name="Site",
endpoint="site_admin",
category="Site"))
admin.add_view(
SiteTypeModelView(SiteType,
db.session,
name="Type",
endpoint="site_type_admin",
category="Site"))
from app import app, db from models import * from flask_admin import Admin from flask_admin.contrib.sqla import ModelView admin = Admin(app) admin.add_view(ModelView(Member, db.session)) admin.add_view(ModelView(Tech, db.session)) admin.add_view(ModelView(Project, db.session)) admin.add_view(ModelView(Section, db.session)) admin.add_view(ModelView(SocialMediaLink, db.session))
from flask import Flask
from config import Configuration
from flask_sqlalchemy import SQLAlchemy
from flask_migrate import Migrate, MigrateCommand
from flask_script import Manager
from flask_admin import Admin
from flask_admin.contrib.sqla import ModelView
app = Flask(__name__)
app.config.from_object(Configuration)
db = SQLAlchemy(app)
migrate = Migrate(app, db)
manager = Manager(app)
manager.add_command('db', MigrateCommand)
from models import Article, Tag, Category
admin = Admin(app)
admin.add_view(ModelView(Article, db.session))
admin.add_view(ModelView(Tag, db.session))
admin.add_view(ModelView(Category, db.session))
url_relative_path="upload/images/",
thumbnail_size=(100, 100, True))
}
# Flask views
@app.route('/')
def index():
return "<a href='/admin/'>Click me to get to Admin!</a>"
@app.before_first_request
def build_sample_db():
db.drop_all()
db.create_all()
# Create admin
admin = Admin(app, "Example: Multiple Upload", template_mode="bootstrap3")
# Add views
admin.add_view(
ModelViewHasMultipleFileAndImage(ModelHasMultipleFileAndImage, db.session))
if __name__ == "__main__":
# Start app
app.run(debug=True)
from flask_admin import Admin
from admin import InvoiceAdmin, StaticFileAdmin, ModelView, CommonAdmin
from app import app, db
from models import Invoice, User, Entity
app.config['FLASK_ADMIN_SWATCH'] = 'slate'
admin = Admin(
app, name='InvoiceManager', template_mode='bootstrap3',
)
admin.add_view(InvoiceAdmin(Invoice, db.session))
admin.add_view(ModelView(User, db.session))
admin.add_view(CommonAdmin(Entity, db.session))
admin.add_view(StaticFileAdmin(app.config['STATIC_DIR'], '/static/', name='Static Files'))
if __name__ == '__main__':
app.run(debug=True)
