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,
