def create_app(settings_override=None): """Returns the IEEE API application instance.""" app = factory.create_app(__name__, __path__, settings_override) init_webassets(app) # This must be tied to the frontend app in order to set the index_view that # prevents not webmasters from accessing the admin panel. admin = Admin(app, 'Auth', index_view=MyAdminIndexView()) for cls in admin_objects: admin.register(cls, MyAdminView) @app.errorhandler(404) def page_not_found(e): return render_template('404.html'), 404 @app.errorhandler(403) def forbidden(e): return render_template('403.html'), 403 @app.errorhandler(500) def internal_server_error(e): return render_template('500.html'), 500 return app
def load_admin(app): admin = Admin(app, 'Prairie Hub Admin') admin.register(models.User, session=db.session) admin.register(models.Tribe, session=db.session) admin.register(models.Photo, session=db.session) admin.register(models.Press, session=db.session) admin.register(models.Testimonial, session=db.session)
def register_admin(app): admin = Admin( app, name="Todo MVC Administration", index_view=AdminIndexView() ) admin.register(Todo, DefaultModelAdmin) admin.register(User, UserModelAdmin) admin.register(Role, DefaultModelAdmin)
def init_app(self, app): from points_tracker.auth import models as auth_models from points_tracker import models as ui_models index_view = ProtectedAdminIndexView(name='Admin Console') admin = SuperAdmin(app, 'points_tracker', index_view=index_view) admin.register(auth_models.User, ProtectedModelView) admin.register(auth_models.Role, ProtectedModelView) admin.register(ui_models.Audio, ProtectedModelView) admin.register(ui_models.AudioTag, ProtectedModelView)
def create_app(package_name, package_path, settings_override=None, register_security_blueprint=True): """Returns a :class:`Flask` application instance configured with common functionality for the Overholt platform. :param package_name: application package name :param package_path: application package path :param settings_override: a dictionary of settings to override :param register_security_blueprint: flag to specify if the Flask-Security Blueprint should be registered. Defaults to `True`. """ app = Flask(package_name, instance_relative_config=True) app.config.from_object('overholt.settings') app.config.from_pyfile('settings.cfg', silent=True) app.config.from_object(settings_override) db.init_app(app) mail.init_app(app) security.init_app(app, SQLAlchemyUserDatastore(db, User, Role), login_form=LoginForm, register_form=RegisterForm, register_blueprint=register_security_blueprint) # set up superadmin from .frontend.admin import AdminIndex, UserAdmin, RoleAdmin admin = Admin(app, name='PyCBM Admin', index_view=AdminIndex(url='/admin', name='Admin Home')) admin.register(User, UserAdmin) admin.register(Role, RoleAdmin) admin.register(Store, session=db.session) admin.register(Category, session=db.session) admin.register(Product, session=db.session) register_blueprints(app, package_name, package_path) app.wsgi_app = HTTPMethodOverrideMiddleware(app.wsgi_app) return app
@superadmin.expose('/') def index(self): return refresh_users() class UserAdmin(ModelAdmin): list_display = ('username',) search_fields = list_display class TagAdmin(ModelAdmin): list_display = ('name', 'value', ) search_fields = list_display if __name__ == "__main__": app.debug = True app.host = '0.0.0.0' app.secret_key = 'testytesttestxx' admin = Admin(app, 'AWS CC') # Add views admin.register(User, UserAdmin, session=db.session) admin.register(Tag, TagAdmin, session=db.session) admin.add_view(RefreshTags(category='Refresh from AWS')) admin.add_view(RefreshUsers(category='Refresh from AWS')) db.create_all() app.run()
tps_to_save.append(tp) db.session.add_all(tps_to_save) db.session.commit() # ---------------- Admin ------------------------- # This section adds models to the admin panel, which # allows use to view them using the superadmin package from flask.ext.superadmin import Admin, model # Create admin admin = Admin(app, 'Simple Models') # Add views admin.register(Chain, session=db.session) admin.register(State, session=db.session) admin.register(Raw_input, session=db.session) admin.register(Reference, session=db.session) admin.register(Transition_probability, session=db.session) admin.register(Interaction, session=db.session) admin.register(Cycle, session=db.session) admin.register(Disability_weight, session=db.session) admin.register(Cost, session=db.session) admin.register(Intervention, session=db.session) admin.register(Stratum, session=db.session) admin.register(Stratum_content, session=db.session) admin.register(Stratum_type, session=db.session) admin.register(Stratum_type_content, session=db.session) admin.register(Transition_probability_by_stratum, session=db.session) admin.register(Variable_by_stratum, session=db.session)
class Post(Document): user = ReferenceField(User) tags = ListField(StringField()) text = StringField() date = DateTimeField() complex = ListField(EmbeddedDocumentField(ComplexEmbedded)) # Flask views @app.route('/') def index(): return '<a href="/admin/">Click me to get to Admin!</a>' if __name__ == '__main__': # Create admin admin = Admin(app, 'Simple Models') class UserModel(model.ModelAdmin): list_display = ('username','email') # only = ('username',) # Register the models admin.register(User, UserModel) admin.register(Post) # Start app app.debug = True app.run('0.0.0.0', 8000)
user_id = db.Column(db.Integer(), db.ForeignKey(User.id)) user = db.relationship(User, backref='posts') def __unicode__(self): return self.title # Flask views @app.route('/') def index(): return '<a href="/admin/">Click me to get to Admin!</a>' if __name__ == '__main__': # Create admin admin = Admin(app, 'Simple Models') admin.locale_selector(get_locale) # Add views admin.register(User, session=db.session) admin.register(Post, session=db.session) # Create DB db.create_all() # Start app app.debug = True app.run('0.0.0.0', 8000)
date = models.DateField() user = models.ForeignKey(User) def __unicode__(self): return self.title # Flask views @app.route('/') def index(): return '<a href="/admin/">Click me to get to Admin!</a>' # Build the manifest of apps and models that are to be synchronized if __name__ == '__main__': # Create admin admin = Admin(app, 'Simple Models') # Add views admin.register(User) admin.register(Post) # Create tables in database if not exists try: install_models(User,Post) except: pass # Start app app.debug = True app.run('0.0.0.0', 8000)
from mongoengine import ( Document, EmbeddedDocument, EmbeddedDocumentField, StringField, ListField, EmailField) class Author(EmbeddedDocument): name = StringField(required=True, max_length=160) email = EmailField() class Comment(EmbeddedDocument): name = StringField(max_length=60) comment = StringField(required=True) class Blog(Document): titre = StringField(required=True, max_length=60) tags = ListField(StringField(max_length=30)) auteur = EmbeddedDocumentField(Author) comments = ListField(EmbeddedDocumentField(Comment)) app = Flask("Presentation Python") app.config['MONGODB_SETTINGS'] = {'DB': 'presentation_python'} app.config['SECRET_KEY'] = "12345" db = MongoEngine(app) admin = Admin(app) admin.register(Blog) if __name__ == "__main__": app.run()
from database import make_db_utils # Database Connection _, db_session, _ = make_db_utils() # App configuration app = Flask(__name__, static_url_path='', static_folder='../static') app.config["SECRET_KEY"] = urandom(24) app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False app.config["SQLALCHEMY_DATABASE_URI"] = environ["SQLALCHEMY_DATABASE_URI"] app.add_url_rule("/", "root", lambda: app.send_static_file("index.html")) # API configuration api = MultiApi(app) api.add_resource(ReadingResource, "/api/reading/") api.add_resource(DeviceResource, "/api/dev/") # Admin and Security configuration admin = Admin(index_view=HomeView("Helmuth")) admin.register(Device, AuthModelView, session=db_session) admin.register(Reading, AuthModelView, session=db_session) admin.register(User, AuthModelView, session=db_session) admin.add_view(UploadView(name="upload")) admin.init_app(app) db = SQLAlchemy(app) user_datastore = SQLAlchemyUserDatastore(db, User, Role) security = Security(app, user_datastore) if __name__ == "__main__": app.run(host="0.0.0.0", port=8000, debug=True)
from flask_bootstrap import Bootstrap import logging, sys from flask.ext.superadmin import Admin logging.basicConfig(stream=sys.stderr) tmpl_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'templates') app = Flask(__name__,template_folder=tmpl_dir) Bootstrap(app) from . import views from . import login from . import models from . import tasks from . import auth from . import forms from . import inject_trades from .database import db admin = Admin(app,index_view=models.MyAdminIndexView()) #admin.register(models.User, session=db.session) admin.register(models.Item, session=db.session) admin.register(models.Trade, session=db.session) admin.register(models.Factory, session=db.session) admin.register(models.Distributor, session=db.session) admin.register(models.ManufactureJob, session=db.session) admin.add_view(models.MyModelView(models.User, db.session)) celery = tasks.make_celery(app)
admin = Admin(app, app.config["PROJECT_NAME"]) 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", metaclass=_AdminBoundDeclarativeMeta) db.Model.query = sqlalchemy._QueryProperty(db) # Automatically include views, files and APIs include_files = set(["views.py", "models.py", "api.py"]) for root, dirname, files in os.walk(app.config["BASEDIR"]): for filename in files: if filename in include_files: relative = os.path.relpath(os.path.join(root, filename))[:-3] module = ".".join(relative.split(os.sep)) __import__(module, level=-1) for cls in model_classes: admin.register(cls, session=db.session, admin_class=SecuredModelView)
def init_app(app, messageService, locatorService): class BroadcastView(BaseView): @expose('/') def index(self): roles = Role.query.all() return self.render('broadcast.jade', roles=roles) @expose('/send', methods=['POST']) def send(self): role_id = request.form.get('role') message = request.form.get('message') if message is None or len(message) == 0: flash("You need to supply a message!") return redirect(url_for('.index')) if role_id is None: flash("You need to select which group to target!") return redirect(url_for('.index')) if role_id < 0: messageService.sendBroadcast(User.query.all(), message) else: role = Role.query.get(role_id) messageService.sendBroadcast(role.users, message) flash("Successfully sent message") return redirect(url_for('.index')) class LocateView(BaseView): @expose('/') def index(self): users = User.query.all() return self.render('locate.jade', users=users) @expose('/send', methods=['POST']) def send(self): sender = User.query.get(request.form.get('sender', 1)) target = User.query.get(request.form.get('target', 1)) locatorService.startLocating(target, sender) flash('Started locating') return redirect(url_for('.index')) @expose('/cheeseit') def cheeseit(self): testuser = Role.query.get(27) messageService.sendCheesit(testuser.users) flash('Delicious topping activated') return redirect(url_for('.index')) class DataView(BaseView): @expose('/') def index(self): users = User.query.all() return self.render('data.jade', users=users) @expose('/send', methods=['POST']) def send(self): target = User.query.get(request.form.get('sender', 1)) action = request.form.get('action') payload = request.form.get('payload') if action is None or len(action) == 0: flash("You need to supply an action!") return redirect(url_for('.index')) if payload is None or len(payload) == 0: flash("You need to supply a payload!") return redirect(url_for('.index')) messageService.sendData(target, payload, action) flash('Successfully sent data') return redirect(url_for('.index')) class UserView(model.ModelAdmin): session = db.session list_display = ('fullname', 'username', 'is_admin') class BeaconView(model.ModelAdmin): session = db.session list_display = ('location', 'uuid') class HashView(BaseView): @expose('/') def index(self): return self.render('hashview.jade') @expose('/send', methods=['POST']) def send(self): pw = request.form.get('password') hashpw = _hash(pw).hexdigest() flash(hashpw) return redirect(url_for('.index')) class AdminView(AdminIndexView): @expose('/') def index(self): return self.render('admin_index.jade') admin = Admin(name='LoKI', index_view=AdminView()) admin.register(Role, session=db.session) admin.register(User, UserView) admin.register(Device, session=db.session) admin.register(AccessToken, session=db.session) admin.register(LocatingRequest, session=db.session) admin.register(Beacon, BeaconView) admin.add_view(BroadcastView(name='Broadcast', category='Tools')) admin.add_view(LocateView(name='Locate', category='Tools')) admin.add_view(DataView(name='Data', category='Tools')) admin.add_view(HashView(name='Hash', category='Tools')) admin.init_app(app)
return 'asdasdasdasd' admin = Admin(app, name="Copylighter") class UserModel(model.ModelAdmin): list_display = ('id','name','email') form_widget_args = { 'name': { 'readonly': True }, } class NoteModel(model.ModelAdmin): list_display = ('id', 'content','created_at',) column_searchable_list = ('content', 'id') fields = ('created_at','tags','content', 'isArchived', 'isSecret') class NoteRefModel(model.ModelAdmin): list_display = ('id', 'note_id','user_id','created_at') class TagRefModel(model.ModelAdmin): list_display = ('id', 'tags','note_id','created_at') admin.register(User, UserModel) admin.register(Note, NoteModel) admin.register(TagRef, TagRefModel) admin.register(NoteRef, NoteRefModel)
from sqlalchemy.orm import sessionmaker engine = create_engine("mysql://root:@localhost/codecalltut", echo=True) Base = declarative_base(engine) db = sqlsoup.SQLSoup("mysql://root:@localhost/codecalltut") app = Flask(__name__) class Prereg(Base): __tablename__ = 'tblprereg' __table_args__ = {'autoload': True} def __repr__(self): return self.username def loadSession(): metadata = Base.metadata Session = sessionmaker(bind=engine) session = Session() return session admin = Admin(app) admin.register(Prereg, session=loadSession()) if __name__ == "__main__": session = loadSession() app.run(debug=True)
from flask import Flask from flask.ext.routing import router from flask.ext.cors import CORS from api import core, db from views import CustomJSONEncoder from views import v1 import configs current_version = v1 urls = ('/v1', v1, '', current_version) app = router(Flask(__name__), urls) app.secret_key = configs.SECRET_KEY app.json_encoder = CustomJSONEncoder cors = CORS(app) if configs.cors else None if configs.DEBUG or configs.UWSGI: import sys if sys.version_info < (3, 0): from flask.ext.superadmin import Admin, model admin = Admin(app) for model in core.Base._decl_class_registry: try: admin.register(core.Base._decl_class_registry[model], session=db) except: pass if __name__ == "__main__": app.run(**configs.options)
date = db.Column(db.DateTime) user_id = db.Column(db.Integer(), db.ForeignKey(User.id)) user = db.relationship(User, backref='posts') def __unicode__(self): return self.title # Flask views @app.route('/') def index(): return '<a href="/admin/">Click me to get to Admin!</a>' if __name__ == '__main__': # Create admin admin = Admin(app, 'Simple Models') admin.locale_selector(get_locale) # Add views admin.register(User, session=db.session) admin.register(Post, session=db.session) # Create DB db.create_all() # Start app app.debug = True app.run('0.0.0.0', 8000)
from flask.ext.routing import router from flask.ext.cors import CORS from api import core, db from views import CustomJSONEncoder from views import v1 import configs current_version = v1 urls = ('/v1', v1, '', current_version ) app = router(Flask(__name__), urls) app.secret_key = configs.SECRET_KEY app.json_encoder = CustomJSONEncoder cors = CORS(app) if configs.cors else None if configs.DEBUG or configs.UWSGI: import sys if sys.version_info < (3, 0): from flask.ext.superadmin import Admin, model admin = Admin(app) for model in core.Base._decl_class_registry: try: admin.register(core.Base._decl_class_registry[model], session=db) except: pass if __name__ == "__main__": app.run(**configs.options)
{'WWW-Authenticate': 'Basic realm="Login Required"'}) def is_authenticated(): auth = flask.request.authorization return auth and check_auth(auth.username, auth.password) class ModelAdmin(_ModelAdmin): def is_accessible(self): return is_authenticated() def _handle_view(self, name, *args, **kwargs): if not self.is_accessible(): return authenticate() class AdminIndexView(_AdminIndexView): @expose('/') def index(self): if not is_authenticated(): return authenticate() return super(AdminIndexView, self).index() admin = Admin(app, index_view=AdminIndexView()) admin.register(User, admin_class=ModelAdmin, session=db.session) if __name__ == '__main__': app.run()
def init_app(self, app): index_view = ProtectedAdminIndexView(name='Admin Console') admin = SuperAdmin(app, 'points_tracker', index_view=index_view) admin.register(models.User, ProtectedModelView)
def __repr__(self): return self.name #### ---------------- Admin ------------------------- from flask.ext.superadmin import Admin, model # Create admin admin = Admin(app, 'Simple Models') # Add views admin.register(Chain, session=db.session) admin.register(State, session=db.session) admin.register(Raw_input, session=db.session) admin.register(Reference, session=db.session) admin.register(Transition_probability, session=db.session) admin.register(Interaction, session=db.session) # admin.add_view(sqlamodel.ModelView(Post, session=db.session)) # Create DB db.create_all() # Start app ### Migration manager
admin = Admin(app, app.config["PROJECT_NAME"]) 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", metaclass=_AdminBoundDeclarativeMeta) db.Model.query = sqlalchemy._QueryProperty(db) # Automatically include views, files and APIs include_files = set(["views.py", "models.py", "api.py"]) for root, dirname, files in os.walk(app.config["BASEDIR"]): for filename in files: if filename in include_files: relative = os.path.relpath(os.path.join(root, filename))[:-3] module = ".".join(relative.split(os.sep)) __import__(module, level=-1) for cls in model_classes: admin.register(cls, session=db.session, admin_class=SecuredModelView)
class Post(Document): user = ReferenceField(User) tags = ListField(StringField()) text = StringField() date = DateTimeField() complex = ListField(EmbeddedDocumentField(ComplexEmbedded)) # Flask views @app.route('/') def index(): return '<a href="/admin/">Click me to get to Admin!</a>' if __name__ == '__main__': # Create admin admin = Admin(app, 'Simple Models') class UserModel(model.ModelAdmin): list_display = ('username', 'email') # only = ('username',) # Register the models admin.register(User, UserModel) admin.register(Post) # Start app app.debug = True app.run('0.0.0.0', 8000)
if adding: instance.set_password(instance.password) self.session.add(instance) self.session.commit() return instance class PostAdminView(BaseAdminModelView): pass class TagAdminView(BaseAdminModelView): pass # admin dashboard admin = Admin(name='Boilerplate', index_view=BaseAdminIndexView()) admin.register(db.User, UserAdminView, session=db.Store.session, name='Users') admin.register(db.Post, PostAdminView, session=db.Store.session, name='Posts') admin.register(db.Tag, TagAdminView, session=db.Store.session, name='Tags') admin.init_app(app) def auth_is_admin(user=None, password=None): adm = db.User.query.filter_by(username=user, password=md5.new(password).hexdigest()).first() if isinstance(adm, db.User): flask_login.login_user(adm) return True return False
# Create customized index view class class MyAdminIndexView(AdminIndexView): def is_accessible(self): return current_user.is_authenticated() and current_user.is_admin() #admin admin = Admin(app, 'Auth', index_view=MyAdminIndexView()) #admin = Admin(app, 'Simple Models') # Add view #admin.add_view(sqlamodel.ModelAdmin(User, session=db.session)) #admin.add_view(MyModelView(Friend, db.session)) #admin.add_view(MyModelView(Ask, db.session)) admin.register(User, session=db.session) admin.register(Ask, session=db.session) admin.register(Friend, session=db.session) admin.register(Review, session=db.session) admin.register(ContactUs, session=db.session) admin.register(Recommendation, session=db.session) admin.register(SendAsk, session=db.session) admin.register(ReplyRecommendation, session=db.session) admin.register(SendRecommendation, session=db.session) admin.register(Ads, session=db.session) #Adding a custom view #admin.add_view(MyView(name="Yello"))
def __unicode__(self): return self.title # Flask views @app.route('/') def index(): return '<a href="/admin/">Click me to get to Admin!</a>' # Build the manifest of apps and models that are to be synchronized if __name__ == '__main__': # Create admin admin = Admin(app, 'Simple Models') # Add views admin.register(User) admin.register(Post) # Create tables in database if not exists try: install_models(User, Post) except: pass # Start app app.debug = True app.run('0.0.0.0', 8000)
class Tag(db.Model): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.Unicode(64)) def __unicode__(self): return self.name # Flask views @app.route('/') def index(): return '<a href="/admin/">Click me to get to Admin!</a>' if __name__ == '__main__': # Create admin admin = Admin(app, 'Simple Models') # Add views admin.register(User, session=db.session) admin.register(Tag, session=db.session) admin.register(Post, session=db.session) # admin.add_view(sqlamodel.ModelView(Post, session=db.session)) # Create DB db.create_all() # Start app app.debug = True app.run('0.0.0.0', 8000)
# -*- coding: utf-8 -*- import sys import inspect from flask import Flask from flask.ext.sqlalchemy import SQLAlchemy import app.models from flask.ext.superadmin import Admin, model app = Flask(__name__) app.config.from_object('config') db = SQLAlchemy(app) if __name__ == '__main__': admin = Admin(app, 'DB ADMIN') for name, obj in inspect.getmembers(sys.modules['app.models']): if inspect.isclass(obj) and hasattr(obj, 'query'): admin.register(obj, session=db.session) app.debug = True app.run('0.0.0.0', 8000)