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 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 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 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
def init_app():
init_login()
admin = Admin(app)
admin.add_view(AdminViews(name='Admin View'))
from flask import Flask
from flask.ext.superadmin import Admin
import sqlsoup
#db = sqlsoup.SQLSoup("mysql://*****:*****@db4free.net/codecalltut")
db = sqlsoup.SQLSoup("mysql://root:@localhost/codecalltut")
users = db.tblprereg.all()
app = Flask(__name__)
admin = Admin(app)
if __name__ == "__main__":
app.run(debug=True)
from flask import Flask
from flask.ext.superadmin import Admin, BaseView, expose
class MyView(BaseView):
@expose('/')
def index(self):
return self.render('index.html')
app = Flask(__name__)
admin = Admin(app)
admin.add_view(MyView(name='Hello 1', endpoint='test1', category='Test'))
admin.add_view(MyView(name='Hello 2', endpoint='test2', category='Test'))
admin.add_view(MyView(name='Hello 3', endpoint='test3', category='Test'))
app.run()
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 flask import Flask
from flask.ext.superadmin import Admin, BaseView, expose
class MyView(BaseView):
@expose('/')
def index(self):
return self.render('index.html')
app = Flask(__name__)
admin = Admin(app)
admin.add_view(MyView(name='Hello'))
app.run()
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)
@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()
from flask.ext.superadmin import Admin from douwallet.admin.views import IndexView admin = Admin(index_view=IndexView()) # register model views from douwallet.models import db from douwallet.models.user import User admin.register(User, session=db.session)
class SecuredAdminIndexView(AdminIndexView):
def is_accessible(self):
admin = current_user.has_role("admin")
if not admin:
flask.flash("You do not have permission to view this site")
logout_user()
return admin
class SecuredModelView(ModelAdmin):
def is_accessible(self):
return current_user.has_role("admin")
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)
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)
from flask import Flask
from flask.ext.superadmin import Admin, model, BaseView, expose
from models import *
class MyView(BaseView):
def is_accessible(self):
return login.current_user.is_authenticated()
@expose('/')
def index():
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')
# Copyright 2013 Alexandre Bulté <alexandre[at]bulte[dot]net>
#
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
from flask.ext.superadmin import Admin, AdminIndexView
from flask.ext.superadmin.model.backends.mongoengine import ModelAdmin
from flask.ext.login import current_user
from webapp import app
from .models import User, DummyContent
# Create customized model view class
class MyModelView(ModelAdmin):
def is_accessible(self):
return current_user.is_authenticated()
# Create customized index view class
class MyAdminIndexView(AdminIndexView):
def is_accessible(self):
return current_user.is_authenticated()
# Create admin
admin = Admin(app, 'Backoffice', index_view=MyAdminIndexView())
# Add view
admin.add_view(MyModelView(User))
admin.add_view(MyModelView(DummyContent))
from flask import Flask
from flask.ext.superadmin import Admin, BaseView, expose
class MyView(BaseView):
@expose('/')
def index(self):
return self.render('index.html')
app = Flask(__name__)
admin = Admin(app)
admin.add_view(MyView(name='Hello'))
app.run()
from flask import Flask
from flask.ext.superadmin import Admin, BaseView, expose
class MyView(BaseView):
@expose('/')
def index(self):
return self.render('index.html')
app = Flask(__name__)
admin = Admin(app)
admin.add_view(MyView(name='Hello 1', endpoint='test1', category='Test'))
admin.add_view(MyView(name='Hello 2', endpoint='test2', category='Test'))
admin.add_view(MyView(name='Hello 3', endpoint='test3', category='Test'))
app.run()
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)
tp_base=0.1,
is_dynamic=False
)
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)
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)
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)
name = db.Column(db.String(4000))
bibtex = db.Column(db.String(2000))
raw_data = db.relationship('Raw_input', backref='reference')
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()
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)
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)
{'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()
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)
# -*- coding: utf-8 -*- """ All of our extensions are initialized here. They are registered in app.py:register_extensions upon app creation """ from flask.ext.sqlalchemy import SQLAlchemy db = SQLAlchemy() from flask.ext.migrate import Migrate migrate = Migrate() from flask.ext.debugtoolbar import DebugToolbarExtension debug_toolbar = DebugToolbarExtension() from flask.ext.bcrypt import Bcrypt bcrypt = Bcrypt() from flask.ext.superadmin import Admin admin = Admin(name="Rest Player Generator (RPG)")
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)
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)
class SecuredAdminIndexView(AdminIndexView):
def is_accessible(self):
admin = current_user.has_role("admin")
if not admin:
flask.flash("You do not have permission to view this site")
logout_user()
return admin
class SecuredModelView(ModelAdmin):
def is_accessible(self):
return current_user.has_role("admin")
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)
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)
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
@expose('/')
def index(self):
return self.render('admin/index.html')
def is_accessible(self):
return current_user.is_authenticated() and current_user.is_admin()
# 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)
#
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
from flask.ext.superadmin import Admin, AdminIndexView
from flask.ext.superadmin.model.backends.mongoengine import ModelAdmin
from flask.ext.login import current_user
from webapp import app
from .models import User, DummyContent
# Create customized model view class
class MyModelView(ModelAdmin):
def is_accessible(self):
return current_user.is_authenticated()
# Create customized index view class
class MyAdminIndexView(AdminIndexView):
def is_accessible(self):
return current_user.is_authenticated()
# Create admin
admin = Admin(app, 'Backoffice', index_view=MyAdminIndexView())
# Add view
admin.add_view(MyModelView(User))
admin.add_view(MyModelView(DummyContent))
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)
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)
