def register_admin(app): """Register admin application.""" admin = Admin( app, template_mode='bootstrap3' ) admin.add_view(AdminUserView(User, db.session))
def register_classes_for_admin(db_session, show_pks=True, name='admin'): """Registers classes for the Admin view that ultimately creates the admin interface. :param db_session: handle to database session :param list classes: list of classes to register with the admin :param bool show_pks: show primary key columns in the admin? """ with app.app_context(): admin_view = Admin(current_app, name=name) for cls in set( cls for cls in current_app.class_references.values() if cls.use_admin): column_list = [column.name for column in cls.__table__.columns.values()] if hasattr(cls, '__view__'): # allow ability for model classes to specify model views admin_view_class = type( 'AdminView', (cls.__view__,), {'form_columns': column_list}) elif show_pks: # the default of Flask-SQLAlchemy is to not show primary # classes, which obviously isn't acceptable in some cases admin_view_class = type( 'AdminView', (AdminModelViewWithPK,), {'form_columns': column_list}) else: admin_view_class = ModelView admin_view.add_view(admin_view_class(cls, db_session))
def activate(admin=True): """Activate each registered model for non-admin use""" with app.app_context(): if getattr(current_app, 'endpoint_classes', None) is None: current_app.endpoint_classes = {} current_app.classes_by_name = {} current_app.table_to_endpoint = {} current_app.classes = [] if not current_app.endpoint_classes: db.metadata.reflect(bind=db.engine) for name, table in db.metadata.tables.items(): try: cls = type(str(name), (sandman_model, db.Model), {'__tablename__': name}) register(cls) except: print name + ' unable to be registered' else: Model.prepare(db.engine) if admin: _prepare_relationships() admin = Admin(app) with app.app_context(): for cls in (cls for cls in current_app.classes if cls.use_admin == True): admin.add_view(ModelView(cls, db.session)) webbrowser.open('http://localhost:5000/admin')
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 create_admin(app=None): admin = Admin(app,name='YuanshanAdmin',index_view=MyIndexView(), base_template='admin/master.html') admin.add_view(UserView(User,db.session)) admin.add_view(PostView(Post,db.session)) # admin.add_view(ModelView(Friend_link, db.session)) admin.add_view(MyAdminView(Tag, db.session))
def test_admin(app): """Test flask-admin interace.""" InvenioUserProfiles(app) assert isinstance(user_profile_adminview, dict) assert 'model' in user_profile_adminview assert 'modelview' in user_profile_adminview admin = Admin(app, name="Test") user_model = user_profile_adminview.pop('model') user_view = user_profile_adminview.pop('modelview') admin.add_view(user_view(user_model, db.session, **user_profile_adminview)) with app.test_request_context(): request_url = url_for('userprofile.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 b'Display Name' in (res.get_data()) assert b'Full Name' in (res.get_data())
def create_app(settings_override=None): """Returns the Overholt dashboard application instance""" app = factory.create_app(__name__, __path__, settings_override) # Configure sentry to track errors on the production app Sentry(app) # Configure flask moment to show nice timestamps Moment(app) # Configure Admin admin = Admin(app, index_view=MyHomeView()) admin.add_view(UserView(db.session, category="Users")) admin.add_view(AdminModel(Role, db.session, category="Users")) # Register custom error handlers if not app.debug: for e in [500, 404]: app.errorhandler(e)(handle_error) app.jinja_env.filters['gravatar'] = gravatar app.jinja_env.filters['format_currency'] = format_currency app.jinja_env.filters['nl2br'] = nl2br app.jinja_env.filters['firstname'] = firstname app.jinja_env.filters['pretty_date'] = pretty_date app.jinja_env.globals.update(current_date=current_date()) return app
def init_app(app): config = { 'url': '/', } imv = ItemManutencaoView() file_upload_path = os.path.join(app.instance_path, u'storage') if not os.path.isdir(file_upload_path): os.makedirs(file_upload_path) views = [ # endereco RegiaoView(), BairroView(), LogradouroView(), # protocolos PlanilhaUploadView(base_path=file_upload_path, name=u'Upload de planilha de protocolos', category=u'Protocolos'), ProtocoloView(), PosteView(imv), imv, # Retirar em prod OrdemServicoView(), # equipamentos EquipamentoView(), PrecoEquipamentoView(), # usuarios UserView(), RoleView(), ] index = IndexView(name='Principal', **config) admin = Admin(app, template_mode='bootstrap3', index_view=index, name='Cidade Iluminada', **config) for view in views: admin.add_view(view)
def get_app(self): app = Flask(__name__) @app.route('/') def index(): return redirect(url_for('admin.index')) class HomeView(AdminIndexView): @expose("/") def index(self): return redirect('/admin/dashboard') admin = Admin( app, name="Honeypot", index_view=HomeView()) admin._menu = [] view = Dashboard( table=self.table_name, sql_conn_id=self.sql_conn_id, sample_data=False) admin.add_view(view) return app
def create_app(options): """ Create the application. Files outside the app directory can import this function and use it to create the application """ app = Flask(__name__) # config app.config.from_object(settings) app.config.update(options) # views as blueprint app.register_blueprint(comments_bp) # db db.init_app(app) # admin admin = Admin(app, name="Comimoc", index_view=LoginView(app.config, name="Index")) admin.add_view(CommentModelView()) admin.add_view(UserModelView()) # login login_manager = LoginManager(app) @login_manager.user_loader def load_user(user_id): # .first() return None if no user as Flask-Login needs return User.objects(id=user_id).first() # CORS @app.after_request def add_headers(response): ''' Add some headers to the response to be able to perform some CORS request ''' if not app.config.get("USE_CORS", False): return response origin = request.headers.get("Origin") if origin not in app.config['CORS_ALLOW_ORIGIN_WHITELIST']: return response response.headers.add('Access-Control-Allow-Origin', origin) if app.config['CORS_ALLOW_CREDENTIALS']: response.headers.add('Access-Control-Allow-Credentials', 'true') response.headers.add('Access-Control-Allow-Methods', app.config['CORS_ALLOW_METHODS']) response.headers.add('Access-Control-Allow-Headers', app.config['CORS_ALLOW_HEADERS']) response.headers.add('Access-Control-Max-Age', app.config['CORS_MAX_AGE']) return response # ping pong @app.route('/ping', methods=['GET']) def ping(): return 'pong', 200 return app
def activate_admin_classes(): """Activate each registed Model in the admin if it was registered with *use_admin=True*.""" _prepare_relationships() admin = Admin(app) with app.app_context(): for cls in (cls for cls in current_app.classes_by_name.values() if cls.use_admin == True): admin.add_view(ModelView(cls, db.session))
def admin(app): admin = Admin(app) session = models.db.session admin.add_view(ProcessModelView(session)) admin.add_view(LogfileModelView(session)) admin.add_view(ModelView(models.Host, session))
def configure_admin(app): from admin.admin_view import AdminIndex from flask.ext.admin.contrib.sqlamodel import ModelView admin = Admin(app, name='My App', index_view=AdminIndex()) admin.add_view(ModelView(User, db.session)) admin.add_view(ModelView(Patient, db.session)) admin.add_view(ModelView(Address, db.session))
def register_extensions(app): db.init_app(app) with app.app_context(): db.create_all() if app.debug: admin = Admin(app) admin.add_view(ModelView(Channel, db.session)) admin.add_view(ModelView(File, db.session))
def init_app(app): views = [ AlunoView(), PalestraView(), PalestraAlunoView(), ] admin = Admin(app) for view in views: admin.add_view(view)
def initialize_user_component(app): # Initialize the Admin # URL describes through which address we access the page. # Endpoint enables us to do url_for('userp') to yield the URL url = '/user' admin = Admin(index_view=HomeView(url=url, endpoint='user', name=lazy_gettext("Home")), name=lazy_gettext("User Profile"), url=url, endpoint="home-user") # admin.add_view(ProfileEditView(name=lazy_gettext("Profile"), url='profile', endpoint='user.profile')) admin.add_view(AppsView(name=lazy_gettext("Apps"), url="apps", endpoint='user.apps')) admin.init_app(app)
def create_app(config): """Creates flask application with configuration """ app = App(__name__) # Configure application app.config.setdefault('DATABASE', 'db.db') if isinstance(config, collections.Mapping): app.config.update(config) else: app.config.from_object(config) # View registering views.register_views(app) # DB connection app.db_engine = create_engine(app.config['DATABASE']) m.Base.metadata.bind = app.db_engine m.Session.configure(bind=app.db_engine) # Image Store app.store = HttpExposedFileSystemStore('images', 'images/') app.wsgi_app = app.store.wsgi_middleware(app.wsgi_app) @app.before_request def store_before_request(): context.push_store_context(app.store) @app.teardown_request def store_teardown_request(exception=None): context.pop_store_context() # Auth app.register_blueprint(auth_blueprint) @app.before_request def before_request(): g.user = get_login_user() # Middlewares SQLAlchemyMiddleware(m.Session, app) # Admin def get_session(): session = getattr(self, '_session', None) if (session is None) or not session.is_active: session = m.Session() setattr(self, '_session', session) return session session = Proxy(get_session) admin = Admin(app) admin.add_view(ModelView(m.Issue, session, category='models')) admin.add_view(ModelView(m.User, session, category='models')) return app
def init_public_admin(app): public_admin_url = '/public' public_admin = Admin(index_view = PublicAdminPanel(url=public_admin_url, endpoint = 'public_admin'), name = lazy_gettext(u"Public laboratories"), url = public_admin_url, endpoint = 'public-admin') public_admin.add_view(PublicSystemsPanel( db.session, name = lazy_gettext(u"Show public systems"), endpoint = 'public_admin_systems', url = 'systems/public')) public_admin.add_view(PublicLaboratoriesPanel( db.session, name = lazy_gettext(u"Show public labs"), endpoint = 'public_admin_labs', url = 'labs/public')) public_admin.add_view(RedirectView('index', name = lazy_gettext(u"Back"), endpoint = 'public_admin_logout', url = 'back')) public_admin.init_app(app)
def init(app, db, auth): class AuthenticateModelView(ModelView): def is_accessible(self): user = auth.get_current_user() if user: return user.is_admin return False class UserAdminView(AuthenticateModelView): column_list = ( 'username', 'is_admin', ) form_columns = ( 'username', 'is_admin', 'password_new', 'password_confirm', ) form_extra_fields = { 'password_new': wtf.PasswordField('Password'), 'password_confirm': wtf.PasswordField('Password (Confirm)'), } def on_model_change(self, form, model, is_created): # Verify the password set_password = check_password_fields( form.password_new, form.password_confirm, required=is_created, ) if set_password: model.password = form.password_new.data # Continue with the normal validation ret = super(UserAdminView, self).on_model_change(form, model, is_created) # Check if we added any errors if len(form.password_new.errors) > 0: raise ValidationError() return ret class EventView(AuthenticateModelView): column_list = ( 'user', 'seen_at', 'beacon_id', 'beacon_distance', ) column_default_sort = 'seen_at' admin = Admin(app) admin.add_view(UserAdminView(db.models.User, db.session)) admin.add_view(EventView(db.models.Event, db.session))
def init_admin(app): from flask.ext.admin.contrib.sqla import ModelView from flask.ext.admin import Admin admin = Admin(app) admin.add_view(ModelView(model.Project, model.db.session)) admin.add_view(ModelView(model.Repository, model.db.session)) admin.add_view(ModelView(model.Maintainer, model.db.session)) admin.add_view(ModelView(model.Language, model.db.session)) admin.add_view(ModelView(model.UsedLanguage, model.db.session))
def init_admin(app): admin = Admin(app, name='re:dash admin', template_mode='bootstrap3') admin.add_view(QueryModelView(models.Query)) admin.add_view(QueryResultModelView(models.QueryResult)) admin.add_view(DashboardModelView(models.Dashboard)) for m in (models.Visualization, models.Widget, models.ActivityLog, models.Group, models.Event): admin.add_view(BaseModelView(m))
def create_app(name=__name__, config={}, static_folder='static', template_folder='templates'): """NOTE: `db_uri` is only a temporary solution. It shall be replaced by something more robust.""" app = Flask(name, static_folder=static_folder, template_folder=template_folder) app.secret_key = 'secret' app.config['SQLALCHEMY_DATABASE_URI'] = os.environ.get('DB_URI') app.config['DEBUG'] = True app.config['REDIS_URL'] = os.environ.get( 'REDIS_URL', 'redis://:password@localhost:6379/0') app.config.update(config) login_manager.init_app(app) login_manager.login_view = 'user.login' redis_store.init_app(app) from bnd.models import db db.init_app(app) from bnd.main import main_module from bnd.curriculum import curriculum_module from bnd.checkpoint import checkpoint_module from bnd.team import team_module from bnd.goal import goal_module from bnd.user import user_module # Blueprint modules app.register_blueprint(main_module, url_prefix='/') app.register_blueprint(curriculum_module, url_prefix='/curriculum') app.register_blueprint(team_module, url_prefix='/team') app.register_blueprint(checkpoint_module, url_prefix='/checkpoint') app.register_blueprint(goal_module, url_prefix='/goal') app.register_blueprint(user_module, url_prefix='/user') from bnd.models import User, Team, Checkpoint, Goal, Evaluation, \ CheckpointEvaluation, Announcement admin = Admin() admin.init_app(app) classes = [User, Team, Checkpoint, Goal, Evaluation, CheckpointEvaluation, Announcement] for cls in classes: admin.add_view(AdminModelView(cls, db.session, endpoint='admin_' + cls.__name__)) app.jinja_env.globals.update( checkpoint_status_class=checkpoint_status_class) return app
def make_admin(app): myadmin = Admin(app, index_view=MyAdminIndexView(), base_template='my_master.html',) #template_mode='bootstrap3') myadmin.add_view(EuFormatView(models.EuFormat)) myadmin.add_view(EuTemplateView(models.EuTemplate)) myadmin.add_view(TranslationRequestView(models.TranslationRequest)) myadmin.add_view(UserView(models.User)) return myadmin
def init_admin(app): admin = Admin(app, name='re:dash admin') views = { models.User: UserModelView(models.User), models.DataSource: DataSourceModelView(models.DataSource) } for m in models.all_models: if m in views: admin.add_view(views[m]) else: admin.add_view(BaseModelView(m))
def create_app(config='dev'): """ Flask application factory :param str config: type of app to build, either "prod" or "dev" """ # Create flask application app = Flask(__name__) app.config.from_object('settings') app.config['ENV'] = config app.jinja_env.trim_blocks = True # Debug toolbar (when debug=true) debug_toolbar = DebugToolbarExtension(app) app.config['DEBUG_TB_PROFILER_ENABLED'] = True app.config['DEBUG_TB_INTERCEPT_REDIRECTS'] = False # Register Blueprints app.register_blueprint(views_base.base) app.register_blueprint(views_blog.blog) # Flask-Assets; bundles all css/js files in minifed file assets = Environment(app) css_all = Bundle('css/bootstrap-flatly.min.css', 'css/highlightjs.min.css', 'css/font-awesome.css', 'css/main.css', filters='cssmin', output='gen/style.css') js_all = Bundle('js/vendor/jquery.min.js', 'js/vendor/bootstrap.min.js', 'js/vendor/showdown-gfm.min.js', 'js/vendor/highlight.min.js', 'js/main.js', filters='jsmin', output='gen/libs.js') assets.register('css_all', css_all) assets.register('js_all', js_all) if app.config['DEBUG']: assets.debug = True app.config['ASSETS_DEBUG'] = True # Set up Flask-User babel = Babel(app) db_adapter = SQLAlchemyAdapter(db, User) user_manager = UserManager(db_adapter, app) # Init Flask-User and bind to app # Init the cache cache.init_app(app) Moment(app) # moment.js Misaka(app, autolink=True, # Misaka Markdown fenced_code=True, lax_html=True, strikethrough=True, superscript=True, tables=True, wrap=True) # Init Admin page admin = Admin(app, index_view=AdminMain(endpoint='admin')) admin.add_view(PostAdminView()) admin.add_view(NewPostView()) admin.add_view(ModelView(Comment, db.session)) static_path = os.path.join(BASE_DIR, 'app', 'static') admin.add_view(FileAdminView(static_path, '/static/', name='Static Files')) # Initialize DB db.init_app(app) return app
def setup_app(app): """Register all administration views with the Flask application.""" app.config.setdefault("ADMIN_CONFIG", dict( name="Admin", url="/admin/", template_mode='bootstrap3', )) # Initialize app admin = Admin(**app.config['ADMIN_CONFIG']) admin.init_app(app) # Create registry and run discovery app.extensions['registry']['admin'] = AdminDiscoveryRegistry( 'admin', app=app, with_setup=True, admin=admin )
def reflect_all_app(database_uri): """Return a Flask application object with all of the tables in *database_uri* automatically added as REST endpoints. :param str database_uri: The SQLAlchemy database URI to reflect """ from sandman.application import get_app app = get_app() app.config['SQLALCHEMY_DATABASE_URI'] = database_uri db.init_app(app) with app.app_context(): admin = Admin(app) app.class_references = {} AutomapModel.prepare( # pylint:disable=maybe-no-member db.engine, reflect=True) for cls in AutomapModel.classes: # pylint:disable=maybe-no-member service_cls = type( str(cls.__table__.name) + 'Service', (Service,), { '__model__': cls, '__endpoint__': str(cls.__table__.name), '__url__': '/' + str(cls.__table__.name).lower() }) admin.add_view(ModelView(cls, db.session)) app.class_references[cls.__table__.name] = cls service_cls.register_service(app) @app.errorhandler(BadRequestException) @app.errorhandler(ForbiddenException) @app.errorhandler(NotAcceptableException) @app.errorhandler(NotFoundException) @app.errorhandler(ConflictException) @app.errorhandler(ServerErrorException) @app.errorhandler(NotImplementedException) @app.errorhandler(ServiceUnavailableException) def handle_application_error(error): # pylint:disable=unused-variable """Handler used to send JSON error messages rather than default HTML ones.""" response = jsonify(error.to_dict()) response.status_code = error.code return response return app
def configure_admin(app): class UserView(ModelView): def is_accessible(self): return login.current_user.is_authenticated() class AppointmentView(ModelView): column_formatters = { "start_time": lambda v, c, m, p: datetime.utcfromtimestamp(m.start_time), # NOQA "end_time": lambda v, c, m, p: datetime.utcfromtimestamp(m.end_time) # NOQA } def is_accessible(self): return login.current_user.is_authenticated() admin = Admin(app) admin.add_view(UserView(User, db.session)) admin.add_view(AppointmentView(Appointment, db.session))
def create_app(settings_override=None): """Returns the straply dashboard application instance""" app = factory.create_app(__name__, __path__, settings_override) Sentry(app) admin = Admin(app, index_view=MyHomeView()) admin.add_view(UserView(db.session, category="Users")) admin.add_view(AdminModel(Role, db.session, category="Users")) admin.add_view(AdminModel(Card, db.session, category="Card")) # Register custom error handlers if not app.debug: for e in [500, 404]: app.errorhandler(e)(handle_error) # Filter out static requests Filter('static') # Register some custom app filters app.jinja_env.filters['gravatar'] = gravatar app.jinja_env.filters['format_currency'] = format_currency app.jinja_env.filters['nl2br'] = nl2br app.jinja_env.filters['firstname'] = firstname app.jinja_env.filters['pretty_date'] = pretty_date app.jinja_env.globals.update(current_date=current_date()) return app
def create_app(): app = Flask(__name__) app.secret_key = 'not a secret key' # FIXME duplicated in database.py if is_production(): app.config['SQLALCHEMY_DATABASE_URI'] = 'postgresql://*****:*****@localhost/watchtower' elif is_scan(): #app.config['SQLALCHEMY_DATABASE_URI'] = 'postgresql://*****:*****@75.101.157.206/watchtower' # TODO assumes static private ip app.config['SQLALCHEMY_DATABASE_URI'] = 'postgresql://*****:*****@10.73.181.115/watchtower' else: app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:////var/watchtower/watchtower.db' db.init_app(app) # admin setup admin = Admin(app) admin.add_view(ModelView(Page, db.session)) class MyModelView(ModelView): def __init__(self, model, session, name=None, category=None, endpoint=None, url=None, **kwargs): for k, v in kwargs.iteritems(): setattr(self, k, v) super(MyModelView, self).__init__(model, session, name=name, category=category, endpoint=endpoint, url=url) def is_accessible(self): # Logic return True #admin.add_view(MyModelView(Version, db.session, column_list=['id', 'foreign_key'])) admin.add_view(ModelView(Version, db.session,)) admin.add_view(ModelView(Element, db.session,)) admin.add_view(ModelView(User, db.session,)) return app
def configure_views(app): user_datastore = SQLAlchemyUserDatastore(db, User, Role) security = Security(app, user_datastore, confirm_register_form=ExtendedRegisterForm) csrf = CsrfProtect(app) migrate = Migrate(app, db) admin = Admin(app, name="Lean Workbench Admin") admin.add_view(UserView(User, db.session)) admin.add_view( ExportView(QuickbooksDailyAccountBalance, db.session, name="Quickbooks")) admin.add_view(ExportView(FacebookPageData, db.session, name="Facebook")) admin.add_view(ExportView(DateCount, db.session, name="Twitter Count")) admin.add_view( ExportView(GoogleAnalyticsVisitors, db.session, name="Visitors")) admin.add_view( ExportView(GoogleAnalyticsSignups, db.session, name="Signups")) print current_user @app.route('/') def index(): if current_user.is_authenticated(): logged_in = True return redirect(url_for('dashboard')) else: logged_in = False return render_template('public.html', logged_in=logged_in) @app.route('/signin', methods=["POST", "GET"]) @app.route('/signup', methods=["POST", "GET"]) def sign(): if current_user.is_authenticated(): return redirect(url_for('dashboard')) return render_template('public.html', logged_in=False) @auth_token_required @app.route('/stats', methods=['POST', 'GET']) @app.route('/stats/1', methods=['POST', 'GET']) @app.route('/onboarding/stick', methods=['POST', 'GET']) @app.route('/onboarding/scale', methods=['POST', 'GET']) @app.route('/onboarding/virality', methods=['POST', 'GET']) @app.route('/onboarding/pay', methods=['POST', 'GET']) @app.route('/onboarding/empathy', methods=['POST', 'GET']) @app.route('/export', methods=['POST', 'GET']) @app.route('/scale', methods=['POST', 'GET']) @app.route('/results', methods=['POST', 'GET']) @app.route('/privacy', methods=['POST', 'GET']) @app.route('/eula', methods=['POST', 'GET']) @app.route('/optimization', methods=['POST', 'GET']) @app.route('/baseline', methods=['POST', 'GET']) @app.route('/operations', methods=['POST', 'GET']) @app.route('/onboarding/done', methods=['GET', 'POST']) @app.route('/dashboard', methods=['POST', 'GET']) def dashboard(): """ """ if not current_user.is_authenticated(): return render_template('public.html', logged_in=False) else: return render_template('public.html', logged_in=True) @app.route('/welcome', methods=['POST', 'GET']) def welcome(): current_user.onboarded = True db.session.add(current_user) db.session.commit() return render_template('public.html', logged_in=True) api = restful.Api(app, decorators=[csrf.exempt]) api.add_resource(HypothesisResource, '/api/v1/hypotheses') api.add_resource(FacebookResource, '/api/v1/facebook') api.add_resource(TwitterResource, '/api/v1/twitter') api.add_resource(WufooResource, '/api/v1/wufoo') api.add_resource(GoogleAnalyticsResource, '/api/v1/google-analytics') api.add_resource(Quickbooks_resource, '/api/v1/quickbooks') api.add_resource(UserResource, '/api/v1/users') api.add_resource(Ghosting_resource, '/api/v1/ghosting') api.add_resource(Scale_resource, '/api/v1/scale')
class RestaurantAdmin(ModelView): column_choice = {'spicy_level': Restaurant.TYPES} form_choices = {'spicy_level': Restaurant.TYPES} class UserAdmin(ModelView): column_exclude_list = ['password', 'openid'] def on_model_change(self, form, user, is_created=False): user.password = bcrypt.generate_password_hash(form.password.data) class PointAdmin(ModelView): can_edit = False column_default_sort = ('avg', True) admin = Admin() models = [(PersonalRestaurantInfor, u'个人餐厅信息'), (Image, u'餐厅图片')] for m in models: _model = ModelView(m[0], db.session, endpoint=m[0].__name__, name=m[1]) admin.add_view(_model) admin.add_view( RestaurantAdmin(Restaurant, db.session, endpoint='Restaurant', name=u'餐厅')) admin.add_view(UserAdmin(User, db.session, endpoint='User', name=u'用户')) admin.add_view(PointAdmin(Point, db.session, endpoint='Point', name=u'读书评分'))
admin.py Contains functionality for providing administrative interfaces to items in the system. """ from admin_views import * import os import os.path as op from flask.ext.admin import Admin from flask.ext.admin.menu import MenuLink from remedy.rad.models import db admin = Admin(name='RAD Remedy Admin', index_view=homeview.AdminHomeView()) admin.add_view( resourceview.ResourceView( db.session, category='Resource', name='All', endpoint='resourceview', )) admin.add_view( resourceview.ResourceRequiringGeocodingView( db.session, category='Resource', name='Needing Geocoding', endpoint='geocode-resourceview')) admin.add_view( resourceview.ResourceRequiringCategoriesView(
# Define the database object which is imported # by modules and controllers db = SQLAlchemy(app) # create the flask login handler lm = LoginManager() lm.init_app(app) lm.login_view = "users.auth" # For sending emails from flask.ext.mail import Mail mail = Mail(app) # For the Admin Page admin = Admin(app, name="name") from app.admin import * assets = Environment(app) from app.users.controllers import users from app.chef.controllers import chef # Registering blueprints app.register_blueprint(users, url_prefix='/users') app.register_blueprint(chef, url_prefix='/chef') from app.users.models import * @app.route('/', methods=['GET'])
sys.setdefaultencoding("utf-8") from flask.ext.admin import Admin, BaseView, expose, form from flask.ext.admin.base import MenuLink from app import app from flask.ext.admin.form import rules from flask.ext.admin.contrib.mongoengine import ModelView from models import User, Post, Upload from flask.ext.security import login_required, logout_user, current_user from flask import redirect, url_for, request, flash, render_template from flask.ext.uploads import UploadSet, IMAGES, configure_uploads from config import UPLOADS_DEFAULT_DEST from flask.ext.admin.contrib import fileadmin import os.path as op # Add administrative views here admin = Admin(name='Admin') # Add views here admin.init_app(app) uploads = UploadSet('uploads', IMAGES) configure_uploads(app, uploads) def get_image_url(id): photo = Upload.objects.get_or_404(id=id) return uploads.url(photo.image_url) app.jinja_env.filters['get_image_url'] = get_image_url
principals = Principal() #### Create the Flask-Restful's instance restful_api = Api() #### Create the Flask-Celery-Helper's instance flask_celery = Celery() #### Create the Flask-DebugToolbar's instance debug_toolbar = DebugToolbarExtension() #### Create the Flask-Cache's instance cache = Cache() #### Create the Flask-Admin's instance flask_admin = Admin() ### Create the Flask-Mail's instance mail = Mail() #### Create the Flask-Assets's instance assets_env = Environment() # Define the set for js and css file. main_css = Bundle('css/bootstrap.css', 'css/bootstrap-theme.css', filters='cssmin', output='assets/css/common.css') main_js = Bundle('js/bootstrap.js', filters='jsmin', output='assets/js/common.js')
def register_admin(app): """注册Flask-Admin""" from flask.ext.admin import Admin from flask.ext.admin.contrib.sqla import ModelView from .models import db, Work, WorkImage, WorkType, Dynasty, Artist, Museum admin = Admin(app) admin.add_view(ModelView(Work, db.session)) admin.add_view(ModelView(WorkImage, db.session)) admin.add_view(ModelView(WorkType, db.session)) admin.add_view(ModelView(Dynasty, db.session)) admin.add_view(ModelView(Artist, db.session)) admin.add_view(ModelView(Museum, db.session))
# coding: utf-8 import conf import xmlrpclib from flask import jsonify from flask.ext.sqlalchemy import SQLAlchemy from flask.ext.admin import Admin from flask.ext.cache import Cache from flask.ext.mail import Mail from flask.ext.login import LoginManager import conf from db import MongoIWeb, MongoAdmin admin = Admin(template_mode='bootstrap3') db = SQLAlchemy() cache = Cache() mail = Mail() login = LoginManager() counter = xmlrpclib.ServerProxy("http://%s:%d" % conf.count_conf['listener']) mongo_iweb = MongoIWeb(conf.mongo_iweb) mongo_admin = MongoAdmin(conf.mongo_iweb) class SessionMixin(object): def to_dict(self, *columns): dct = {} for col in columns: value = getattr(self, col) if isinstance(value, datetime.datetime): value = value.strftime('%Y-%m-%d %H:%M:%S')
blueprint = Blueprint('bp_admin2', __name__, url_prefix='/admin2') class MyView(BaseView): def is_accessible(self): if 'user' in session: if session['user'].priv_level < Auth.member: return True @expose('/') def index(self): return self.render('admin/index.html') admin = Admin(app, name='Officers Page', url='/admin2') admin.add_view(ModelView(Club, db.session, category='Direct DB Table Access')) admin.add_view(ModelView(Member, db.session, category='Direct DB Table Access')) admin.add_view( ModelView(Content, db.session, category='Direct DB Table Access')) admin.add_view(ModelView(Event, db.session, category='Direct DB Table Access')) admin.add_view( ModelView(Attendance, db.session, category='Direct DB Table Access')) admin.add_view(ModelView(RSVP, db.session, category='Direct DB Table Access')) admin.add_view( ModelView(Project, db.session, category='Direct DB Table Access')) admin.add_view( ModelView(ProjectMembership, db.session, category='Direct DB Table Access'))
from flask.ext.security import Security, SQLAlchemyUserDatastore from flask_wtf.csrf import CsrfProtect from config import FIRST_USER_PASS, FIRST_USER_NAME # Initialize the app and database, import the config app = Flask(__name__) app.config.from_object('config') db = SQLAlchemy(app) CsrfProtect(app) app.killswitch = 0 # setup db, create the db, setup security, and add first user from app import models userstore = SQLAlchemyUserDatastore(db, models.User, None) sec = Security(app, userstore) db.create_all() try: userstore.create_user(email=FIRST_USER_NAME, password=FIRST_USER_PASS) db.session.commit() except: db.session.rollback() #this loads all views from app.views import main, admin #admin setup _admin = Admin(app, 'NYX Admin', template_mode='bootstrap3', index_view=admin.ProtectedIndexView()) _admin.add_link(MenuLink(name='Back to Site', url='/')) _admin.add_view(admin.UserModelView(models.User, db.session)) _admin.add_view(admin.BotModelView(models.Bot, db.session))
def init_admin(): admin = Admin(app, name=u"gMission Admin Control Panel") for model in all_models(): print 'to add in admin portal:', model.__name__ admin.add_view(ModelView(model, db.session, name="%s" % model.__name__))
def index(self): if current_user.is_anonymous(): current_user.name = u'anonymous' return self.render('admin.html', debug=app.debug, user=current_user) @expose('/login', methods=['GET']) def login(self): if login.is_privileged(): user = Q(User.query).one_or_default(mail=u'*****@*****.**') if user: login_user(user) return redirect('/admin/') @expose('/logout') def logout(self): logout_user() return redirect('/admin/') ############################################################################### ############################################################################### admin = Admin(app, name='NoTex', index_view=IndexView(name='Admin')) ############################################################################### ###############################################################################
}, 'topics': { 'widget': widgets.CheckboxSelectWidget(multiple=True) } } form_widget_args = {'issues': {'class': 'checkbox-list-col-2'}} def on_form_prefill(self, form, id): super(AnalysisNatureView, self).on_form_prefill(form, id) form.issues.query = Issue.all() form.topics.query = Topic.all() admin_instance = Admin(url='/admin', base_template='admin/custom_master.html', name="Dexter Admin", index_view=MyIndexView(), template_mode='bootstrap3') admin_instance.add_view( UserView(User, db.session, name="Users", endpoint='user')) admin_instance.add_view( CountryView(Country, db.session, name="Countries", endpoint='country')) admin_instance.add_view( AnalysisNatureView(AnalysisNature, db.session, name="Analyses", endpoint='analyses')) admin_instance.add_view( MediumView(Medium, db.session,
'status': {'choices': _status_choices, 'coerce': int}, } form_columns = ['title', 'body', 'status', 'author', 'tags'] form_overrides = {'status': SelectField} form_ajax_refs = { 'author': { 'fields': (User.name, User.email), }, } class UserModelView(ModelView): column_filters = ('email', 'name', 'admin', 'active') column_list = ['email', 'name', 'active', 'admin', 'created_timestamp'] column_searchable_list = ['email', 'name'] form_columns = ['email', 'password', 'name', 'active', 'admin'] form_extra_fields = { 'password': PasswordField('New password'), } def on_model_change(self, form, model, is_created): if form.password.data: model.password_hash = User.make_password(form.password.data) return super(UserModelView, self).on_model_change(form, model, is_created) admin = Admin(app, 'Blog Admin', index_view=IndexView()) admin.add_view(EntryModelView(Entry, db.session)) admin.add_view(SlugModelView(Tag, db.session)) admin.add_view(UserModelView(User, db.session)) admin.add_view(BlogFileAdmin(app.config['STATIC_DIR'], '/static/', name='StaticFiles'))
from flask.ext.sqlalchemy import SQLAlchemy from raven.contrib.flask import Sentry DEFAULT_DB_URI = 'sqlite://' app = Flask(__name__) for key, value in os.environ.items(): if not key.startswith('CINCH_'): continue config_key = key.replace('CINCH_', '', 1) app.config[config_key] = value app.secret_key = app.config['SECRET_KEY'] if 'SENTRY_DSN' in app.config: Sentry(app, dsn=app.config['SENTRY_DSN']) db_uri = app.config.get('DB_URI', DEFAULT_DB_URI) app.config['SQLALCHEMY_DATABASE_URI'] = db_uri db = SQLAlchemy(app) admin = Admin(app) import cinch.views import cinch.auth.views import cinch.github cinch # pyflakes
def init_flaskadmin(urlprefix="", secret="fKY7kJ2xSrbPC5yieEjV", override_admin=None, override_flaskadminapp=None): global flaskadminapp, admin if not override_flaskadminapp: flaskadminapp = Flask(__name__) flaskadminapp.debug = True flaskadminapp.secret_key = secret flaskadminapp.config.update(dict(PREFERRED_URL_SCHEME='https')) else: flaskadminapp = override_flaskadminapp # lets add our template directory my_loader = jinja2.ChoiceLoader([ flaskadminapp.jinja_loader, jinja2.FileSystemLoader(resole_uri("gengine:templates")), ]) flaskadminapp.jinja_loader = my_loader flaskadminapp.add_url_rule('/static_gengine/<path:filename>', endpoint='static_gengine', view_func=get_static_view( 'gengine:flask_static', flaskadminapp)) @flaskadminapp.context_processor def inject_version(): return { "gamification_engine_version": pkg_resources.get_distribution("gamification-engine").version } if not override_admin: admin = Admin(flaskadminapp, name="Gamification Engine - Admin Control Panel", base_template='admin_layout.html', url=urlprefix + "/admin") else: admin = override_admin admin.add_view(ModelViewAchievement(DBSession, category="Rules")) admin.add_view(ModelViewGoal(DBSession, category="Rules")) admin.add_view(ModelView(AchievementProperty, DBSession, category="Rules")) admin.add_view(ModelView(AchievementReward, DBSession, category="Rules")) admin.add_view(ModelViewTranslationVariable(DBSession, category="Rules")) admin.add_view(ModelView(Translation, DBSession, category="Rules")) admin.add_view(ModelViewAchievementCategory(DBSession, category="Settings")) admin.add_view(ModelView(Variable, DBSession, category="Settings")) admin.add_view(ModelViewProperty(DBSession, category="Settings")) admin.add_view(ModelViewReward(DBSession, category="Settings")) admin.add_view(ModelView(Language, DBSession, category="Settings")) admin.add_view( MaintenanceView(name="Maintenance", category="Settings", url="maintenance")) admin.add_view(ModelViewValue(DBSession, category="Debug")) admin.add_view(ModelViewGoalEvaluationCache(DBSession, category="Debug")) admin.add_view(ModelViewUser(DBSession, category="Debug")) admin.add_view(ModelView(AchievementUser, DBSession, category="Debug"))
from flask.ext.admin import Admin, AdminIndexView, expose from flask_mail import Message as MailMessage from __init__ import app, db, mail from models import User, Role, Stuff, Category, StuffType, Request from flask.ext.admin.contrib.sqla import ModelView class DemoAdminIndexView(AdminIndexView): def is_accessible(self): return current_user.is_authenticated() and current_user.is_admin admin = Admin(app, url='/admin', base_template='admin_layout.html', index_view=DemoAdminIndexView()) class ExtendedModelView(ModelView): def is_accessible(self): return current_user.roles[0].name == 'admin' def __init__(self, model, session, **kwargs): # You can pass name and other parameters if you want to available_settings = [ 'column_list', 'column_searchable_list', 'list_template', 'column_filters', 'column_sortable_list' ] for setting in available_settings: if setting in kwargs:
from flask import Flask from flask.ext.admin import Admin, BaseView, expose app = Flask(__name__) class AdminTestView(BaseView): def is_accessible(self): return login.current_user. @expose('/') def index(self): return self.render('index.html') admin = Admin(app) admin.add_view(AdminTestView(name='Item1', endpoint='item1', category='DropDown')) admin.add_view(AdminTestView(name='Item2', endpoint='item2', category='DropDown')) admin.add_view(AdminTestView(name='Item3', endpoint='item3', category='DropDown')) app.run(debug=True)
name = db.Column(db.String(60)) group = db.Column(db.String(30)) date = db.Column(db.String(20)) time = db.Column(db.String(10)) timestamp = db.Column(db.String(50)) sync_status = db.Column(db.String(10), unique=False, default='Pending') class ravenAdmin(sqla.ModelView): column_display_pk = True can_edit = False can_delete = False can_create = False admin = Admin(app, name='Scuola Gesu Bambino', template_mode='bootstrap3') admin.add_view(ravenAdmin(Student, db.session)) admin.add_view(ravenAdmin(Log, db.session)) def get_student_data(id_no): return Student.query.filter_by(id_no=id_no).first() def log(student, date, time): timestamp = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S:%f') student_name = student.last_name + ', ' + student.first_name if student.middle_name: student_name += ' ' + student.middle_name[:1] + '.' log_item = Log(id_no=student.id_no,
"""This is where we initialize all of the packages we will use and create the app object""" from flask import Flask from flask.ext.sqlalchemy import SQLAlchemy from flask.ext.bcrypt import Bcrypt from flask.ext.login import LoginManager from flask.ext.admin import Admin from werkzeug.contrib.fixers import ProxyFix app = Flask(__name__) app.config.from_object('config') db = SQLAlchemy(app) bcrypt = Bcrypt(app) login = LoginManager(app) admin = Admin(app, name=app.config.get('BLOG_NAME', 'blog')) app.wsgi_app = ProxyFix(app.wsgi_app) from blog import views
def init_admin(app): admin = Admin(app, index_view=IndexView(name="Add Match"), name="genkstaADMIN") admin.add_view(SeasonView()) admin.add_view(PlayerView()) admin.add_view(SeasonStatsView()) admin.add_view(MatchView()) admin.add_view(PlayerMatchStatsView()) admin.add_view(PlayerMatchRatingView()) admin.add_view(GoToIndex(name='go to "/"'))
from flask.ext.sqlalchemy import SQLAlchemy from flask.ext.admin import Admin from flask_marshmallow import Marshmallow import structlog from structlog.stdlib import LoggerFactory from structlog.threadlocal import wrap_dict structlog.configure( context_class=wrap_dict(dict), logger_factory=LoggerFactory(), ) app = Flask(__name__) app.config.from_object('settings') admin = Admin(app, name='DynoUp', template_mode='bootstrap3') db = SQLAlchemy(app) ma = Marshmallow(app) def make_celery(app): celery = Celery(app.import_name, broker=app.config['CELERY_BROKER_URL']) celery.conf.update(app.config) TaskBase = celery.Task class ContextTask(TaskBase): abstract = True def __call__(self, *args, **kwargs): with app.app_context(): return TaskBase.__call__(self, *args, **kwargs)
def event_attend(): if request.method == 'POST': event_id = request.form['event_id'] user_id = request.form['user_id'] if event_id and user_id: attend = Attend(event_id=event_id, user_id=user_id) db.session.add(attend) db.session.commit() return 'F**k yeah' @app.route('/users/list') def users_show(): result = db.session.query(User).all() result_list = [] for i in result: result_list.append(i.to_json()) return json.dumps(result_list) @app.route('/event/search') def event_search(): return 'Hello World!' admin = Admin(app, name='Can lah!') admin.add_view(ModelView(User, db.session)) admin.add_view(ModelView(Event, db.session)) admin.add_view(ModelView(Category, db.session)) admin.add_view(ModelView(Attend, db.session)) if __name__ == '__main__': app.run(host='0.0.0.0', port=80)
def init_app(app): 'Set up Flask-Admin views here' admin = Admin(app, name='Site Administration', index_view=LoginFriendlyAdminIndexView()) admin.add_view(SiteConfigView(name='Settings')) admin.add_view(UserModelView(User, db.session, category='Models'))
# This callback executes when the user saves changes to a newly-created or edited User -- before the changes are # committed to the database. def on_model_change(self, form, model, is_created): # If the password field isn't blank... if len(model.password2): # ... then encrypt the new password prior to storing it in the database. If the password field is blank, # the existing password in the database will be retained. model.password = utils.encrypt_password(model.password2) # Customized Role model for SQL-Admin class RoleAdmin(sqla.ModelView): # Prevent administration of Roles unless the currently logged-in user has the "admin" role def is_accessible(self): return current_user.has_role('admin') # Initialize Flask-Admin admin = Admin(app) # Add Flask-Admin views for Users and Roles admin.add_view(UserAdmin(User, db.session)) admin.add_view(RoleAdmin(Role, db.session)) # If running locally, listen on all IP addresses, port 8080 if __name__ == '__main__': app.run(host='0.0.0.0', port=int('8080'), debug=app.config['DEBUG'])
def create_admin(app): admin = Admin(app, name='Admin', index_view=IndexView()) admin.add_view(CategoriesView(db.session)) admin.add_view(ProductsView(db.session)) admin.add_view(TemplatesView()) admin.add_view(AssetsView())
def init(app, new_cache): global admin global cache session = getSession() cache = new_cache admin = Admin(app, index_view=LoginView(name='Login/Logout')) admin.add_view(AuthModelView(RuleType, session)) admin.add_view(AuthModelView(ScoreType, session)) admin.add_view(AuthModelView(TournamentType, session)) admin.add_view(AuthModelView(Team, session)) admin.add_view(AuthModelView(TournamentExecutionError, session)) cleanupSession()
from flask import Flask from flask.ext.sqlalchemy import SQLAlchemy from flask.ext.login import LoginManager from flask.ext.admin import Admin app = Flask(__name__) app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:////tmp/test.db' app.config['WTF_CSRF_SECRET_KEY'] = 'random key for form' db = SQLAlchemy(app) app.secret_key = 'some_random_key' login_manager = LoginManager() login_manager.init_app(app) login_manager.login_view = 'auth.login' import my_app.auth.views as views admin = Admin(app, index_view=views.MyAdminIndexView()) admin.add_view(views.HelloView(name='Hello')) admin.add_view(views.UserAdminView(views.User, db.session)) from my_app.auth.views import auth app.register_blueprint(auth) db.create_all()
from flask.ext.sqlalchemy import SQLAlchemy db = SQLAlchemy() from flask.ext.login import LoginManager login_manager = LoginManager() from flask.ext.admin import Admin admin = Admin() import tweepy twitter_api = tweepy.API()
app.jinja_env.filters['alert_class'] = alert_class_filter # Admin interface class SecuredAdminIndexView(AdminIndexView): def is_accessible(self): return current_user.has_role("admin") class SecuredModelView(ModelView): def is_accessible(self): return current_user.has_role("admin") admin = Admin(app, "Auth", index_view=SecuredAdminIndexView()) model_classes = [] if app.config.get("AUTOGENERATE_MODEL_ADMIN", True): # We have to hook in to the db.Model metaclass to keep track of any table # classes we define class _AdminBoundDeclarativeMeta(sqlalchemy._BoundDeclarativeMeta): def __init__(self, name, bases, d): super(self.__class__, self).__init__(name, bases, d) if name != "Model": model_classes.append(self) db.Model = sqlalchemy.declarative_base( cls=sqlalchemy.Model, name="Model", mapper=sqlalchemy.signalling_mapper,