def init_app(app):
admin.name = app.config.TITLE
#admin.base_template='layout.html',
admin.template_mode = "bootstrap4"
admin.init_app(app)
admin.add_view(sqla.ModelView(Player, db.session))
admin.add_view(sqla.ModelView(Pstats, db.session))
admin.add_view(UserAdmin(User, db.session))
def create_app():
app = Flask(__name__)
app.config[
'SQLALCHEMY_DATABASE_URI'] = 'mysql+mysqldb://root:@localhost/knowledge_management?charset=utf8'
#app.config["SQLALCHEMY_DATABASE_URI"] = 'sqlite:///flask-admin.db'
# Create modules
app.register_blueprint(indexModule)
app.register_blueprint(themeModule)
app.register_blueprint(groupModule)
app.register_blueprint(relationModule)
app.register_blueprint(constructionModule)
app.register_blueprint(adminModule)
app.register_blueprint(brustModule)
app.config['DEBUG'] = True
app.config['ADMINS'] = frozenset(['*****@*****.**'])
app.config['SECRET_KEY'] = 'SecretKeyForSessionSigning'
'''
app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql+mysqldb://%s:@%s/%s?charset=utf8' % (MYSQL_USER, MYSQL_HOST, MYSQL_DB)
app.config['SQLALCHEMY_ECHO'] = False
'''
app.config['DATABASE_CONNECT_OPTIONS'] = {}
app.config['THREADS_PER_PAGE'] = 8
app.config['CSRF_ENABLED'] = True
app.config['CSRF_SESSION_KEY'] = 'somethingimpossibletoguess'
# Enable the toolbar?
app.config['DEBUG_TB_ENABLED'] = app.debug
# Should intercept redirects?
app.config['DEBUG_TB_INTERCEPT_REDIRECTS'] = True
# Enable the profiler on all requests, default to false
app.config['DEBUG_TB_PROFILER_ENABLED'] = True
# Enable the template editor, default to false
app.config['DEBUG_TB_TEMPLATE_EDITOR_ENABLED'] = True
# debug toolbar
# toolbar = DebugToolbarExtension(app)
# Create database
db.init_app(app)
with app.test_request_context():
db.create_all()
# init security
security.init_app(app, datastore=user_datastore)
# init admin
admin.init_app(app)
admin.add_view(sqla.ModelView(User, db.session))
admin.add_view(sqla.ModelView(Role, db.session))
return app
def start_api(HOST = '0.0.0.0' ,PORT = None):
db.create_all()
with app.app_context():
# populate the database
for i in range(300):
reader = Person(name='Reader '+str(i), email="reader_email"+str(i) )
author = Person(name='Author '+str(i), email="author_email"+str(i) )
book = Book(title='book_title' + str(i))
review = Review(reader_id=reader.id, book_id=book.id, review='review ' + str(i))
publisher = Publisher(name = 'name' + str(i))
publisher.books.append(book)
reader.books_read.append(book)
author.books_written.append(book)
db.session.add(reader)
db.session.add(author)
db.session.add(book)
db.session.add(publisher)
db.session.add(review)
db.session.commit()
swagger_host = HOST
if PORT and PORT != 80:
swagger_host += ':{}'.format(PORT)
api = Api(app, api_spec_url = '/api/swagger', host = swagger_host, schemes = [ "http", "https" ], description = description )
# Flask-Admin Config
admin = Admin(app, url='/admin')
for model in [ Person, Book, Review, Publisher] :
# add the flask-admin view
admin.add_view(sqla.ModelView(model, db.session))
# Create an API endpoint
api.expose_object(model)
def create_api(app, HOST="localhost", PORT=5000, API_PREFIX=""):
api = SAFRSAPI(app, host=HOST, port=PORT, prefix=API_PREFIX)
api.expose_object(User)
user = User(name="test", email="*****@*****.**")
print("Starting API: http://{}:{}/{}".format(HOST, PORT, API_PREFIX))
admin = Admin(app, url="/admin")
admin.add_view(sqla.ModelView(User, db.session))
def init_app(app):
admin.name = app.config.TITLE
admin.url = '/'
admin.template_mode = "bootstrap3"
admin.add_view(sqla.ModelView(Video, db.session))
admin.add_view(UserAdmin(User, db.session, name='Users'))
admin.init_app(app)
def start_api(HOST="0.0.0.0", PORT=None):
with app.app_context():
db.init_app(app)
db.create_all()
# populate the database
for i in range(300):
reader = Person(name="Reader " + str(i),
email="reader_email" + str(i))
author = Person(name="Author " + str(i),
email="author_email" + str(i))
book = Book(title="book_title" + str(i))
review = Review(reader_id=reader.id,
book_id=book.id,
review="review " + str(i))
publisher = Publisher(name="name" + str(i))
publisher.books.append(book)
reader.books_read.append(book)
author.books_written.append(book)
for obj in [reader, author, book, publisher, review]:
db.session.add(obj)
db.session.commit()
swagger_host = HOST
if PORT and PORT != 80:
swagger_host += ":{}".format(PORT)
custom_swagger = {
"info": {
"title": "New Title"
},
"securityDefinitions": {
"ApiKeyAuth": {
"type": "apiKey",
"in": "header",
"name": "My-Cookie"
}
}
} # Customized swagger will be merged
api = SAFRSAPI(
app,
host=swagger_host,
port=PORT,
prefix=OAS_PREFIX,
api_spec_url=OAS_PREFIX + "/swagger",
custom_swagger=custom_swagger,
schemes=["http", "https"],
description=description,
)
# Flask-Admin Config
admin = Admin(app, url="/admin")
for model in [Person, Book, Review, Publisher]:
# add the flask-admin view
admin.add_view(sqla.ModelView(model, db.session))
# Create an API endpoint
api.expose_object(model)
def configure(app):
# Create admin
admin = Admin(app, name='Example: SQLAlchemy', template_mode='bootstrap3')
# Add views
admin.add_view(UserAdmin(User, db.session))
admin.add_view(sqla.ModelView(Tag, db.session))
admin.add_view(PostAdmin(db.session))
def start_api(HOST='0.0.0.0', PORT=80):
db.create_all()
with app.app_context():
# populate the database
for i in range(50):
reader = Person(name='Reader ' + str(i),
email="reader_email" + str(i))
author = Person(name='Author ' + str(i),
email="author_email" + str(i))
book = Book(title='book_title' + str(i))
review = Review(reader_id=reader.id,
book_id=book.id,
review='review ' + str(i))
publisher = Publisher(name='name' + str(i))
publisher.books.append(book)
reader.books_read.append(book)
author.books_written.append(book)
db.session.add(reader)
db.session.add(author)
db.session.add(book)
db.session.add(publisher)
db.session.add(review)
user = User(username='******')
user.hash_password('admin')
db.session.add(user)
db.session.commit()
api = Api(app,
api_spec_url='/api/swagger',
host='{}:{}'.format(HOST, PORT),
schemes=["http"],
description=description)
# Flask-Admin Config
admin = Admin(app,
url='/admin',
index_view=MyAdminIndexView(),
base_template='my_master.html')
for model in [Person, Book, Review, Publisher, User]:
# add the flask-admin view
admin.add_view(sqla.ModelView(model, db.session))
# Create an API endpoint
api.expose_object(model)
# Set the JSON encoder used for object to json marshalling
app.json_encoder = SAFRSJSONEncoder
# Register the API at /api
swaggerui_blueprint = get_swaggerui_blueprint('/api',
'/api/swagger.json')
app.register_blueprint(swaggerui_blueprint, url_prefix='/api')
@app.route('/')
def goto_api():
return redirect('/api')
def start_api(swagger_host="0.0.0.0", PORT=None):
# Add startswith methods so we can perform lookups from the frontend
SAFRSBase.startswith = startswith
# Needed because we don't want to implicitly commit when using flask-admin
SAFRSBase.db_commit = False
with app.app_context():
db.init_app(app)
db.create_all()
# populate the database
NR_INSTANCES = 200
for i in range(NR_INSTANCES):
reader = Person(name="Reader " + str(i), email="reader@email" + str(i), password=hashlib.sha256(bytes(i)).hexdigest())
author = Person(name="Author " + str(i), email="author@email" + str(i))
book = Book(title="book_title" + str(i))
review = Review(reader_id=reader.id, book_id=book.id, review="review " + str(i))
publisher = Publisher(name="publisher" + str(i))
publisher.books.append(book)
reader.books_read.append(book)
author.books_written.append(book)
reader.friends.append(author)
author.friends.append(reader)
if i % 20 == 0:
reader.comment = ""
for obj in [reader, author, book, publisher, review]:
db.session.add(obj)
db.session.commit()
custom_swagger = {
"info": {"title": "New Title"},
"securityDefinitions": {"ApiKeyAuth": {"type": "apiKey", "in": "header", "name": "My-ApiKey"}},
} # Customized swagger will be merged
api = SAFRSAPI(
app,
host=swagger_host,
port=PORT,
prefix=API_PREFIX,
api_spec_url=API_PREFIX + "/swagger",
custom_swagger=custom_swagger,
schemes=["http", "https"],
description=description,
)
for model in [Person, Book, Review, Publisher]:
# Create an API endpoint
api.expose_object(model)
# see if we can add the flask-admin views
try:
admin = Admin(app, url="/admin")
for model in [Person, Book, Review, Publisher]:
admin.add_view(sqla.ModelView(model, db.session))
except Exception as exc:
print(f"Failed to add flask-admin view {exc}")
def register(app, db):
# create admin
admin_view = admin.Admin(app, name='eKonek', template_mode='bootstrap3')
# add views
admin_view.add_view(UserView(User, db.session))
admin_view.add_view(BookingView(Booking, db.session))
admin_view.add_view(BookingRequestView(BookingRequest, db.session))
admin_view.add_view(FeedbackView(Feedback, db.session))
admin_view.add_view(ServiceView(Service, db.session))
admin_view.add_view(sqla.ModelView(ResetPassword, db.session))
def start_api(HOST='0.0.0.0', PORT=None):
with app.app_context():
db.init_app(app)
db.create_all()
# populate the database
for i in range(300):
reader = Person(name='Reader ' + str(i),
email='reader_email' + str(i))
author = Person(name='Author ' + str(i),
email='author_email' + str(i))
book = Book(title='book_title' + str(i))
review = Review(reader_id=reader.id,
book_id=book.id,
review='review ' + str(i))
publisher = Publisher(name='name' + str(i))
publisher.books.append(book)
reader.books_read.append(book)
author.books_written.append(book)
for obj in [reader, author, book, publisher, review]:
db.session.add(obj)
db.session.commit()
swagger_host = HOST
if PORT and PORT != 80:
swagger_host += ':{}'.format(PORT)
custom_swagger = {
"info": {
"title": "New Title"
}
} # Customized swagger will be merged
api = SAFRSAPI(app,
host=swagger_host,
port=PORT,
prefix=OAS_PREFIX,
api_spec_url=OAS_PREFIX + '/swagger',
custom_swagger=custom_swagger,
schemes=['http', 'https'],
description=description)
# Flask-Admin Config
admin = Admin(app, url='/admin')
for model in [Person, Book, Review, Publisher]:
# add the flask-admin view
admin.add_view(sqla.ModelView(model, db.session))
# Create an API endpoint
api.expose_object(model)
def start_api(swagger_host="0.0.0.0", PORT=None):
with app.app_context():
db.init_app(app)
db.create_all()
# populate the database
NR_INSTANCES = 200
for i in range(NR_INSTANCES):
reader = Person(name="Reader " + str(i), email="reader@email" + str(i), password=str(i))
author = Person(name="Author " + str(i), email="author@email" + str(i), password=str(i))
book = Book(title="book_title" + str(i))
review = Review(reader_id=2 * i + 1, book_id=book.id, review=f"review {i}")
publisher = Publisher(name="publisher" + str(i))
publisher.books.append(book)
reader.books_read.append(book)
author.books_written.append(book)
reader.friends.append(author)
author.friends.append(reader)
if i % 20 == 0:
reader.comment = ""
for obj in [reader, author, book, publisher, review]:
db.session.add(obj)
db.session.commit()
custom_swagger = {
"info": {"title": "My Customized Title"},
"securityDefinitions": {"ApiKeyAuth": {"type": "apiKey", "in": "header", "name": "My-ApiKey"}},
} # Customized swagger will be merged
api = SAFRSAPI(
app,
host=swagger_host,
port=PORT,
prefix=API_PREFIX,
custom_swagger=custom_swagger,
schemes=["http", "https"],
description=description,
)
for model in [Person, Book, Review, Publisher]:
# Create an API endpoint
api.expose_object(model)
# add the flask-admin views
admin = Admin(app, url="/admin")
for model in [Person, Book, Review, Publisher]:
admin.add_view(sqla.ModelView(model, db.session))
def create_api(app, HOST="localhost", PORT=5000, API_PREFIX=api_prefix):
# Add startswith methods so we can perform lookups from the frontend
SAFRSBase.startswith = startswith
# Needed because we don't want to implicitly commit when using flask-admin
SAFRSBase.db_commit = False
api = SAFRSAPI(app, host=HOST, port=PORT, prefix=API_PREFIX)
for model in Models:
dir(model)
api.expose_object(model)
# see if we can add the flask-admin views
try:
admin = Admin(app,
name=app_environment,
url="/admin",
template_mode=app_bootstrap)
for model in Models:
admin.add_view(sqla.ModelView(model, db.session))
except Exception as exc:
print(f"Failed to add flask-admin view {exc}")
print("Starting API: http://{}:{}/{}".format(HOST, PORT, API_PREFIX))
return form
def _get_parent_list(self):
# only show available pets in the form
return Pet.query.filter_by(available=True).all()
def __unicode__(self):
return self.name
# Create admin
admin = admin.Admin(app,
name='Example: SQLAlchemy - Filtered Form Selectable',
template_mode='bootstrap3')
admin.add_view(PersonAdmin(Person, db.session))
admin.add_view(sqla.ModelView(Pet, db.session))
if __name__ == '__main__':
# Recreate DB
db.drop_all()
db.create_all()
person = Person(name='Bill')
pet1 = Pet(name='Dog', available=True)
pet2 = Pet(name='Fish', available=True)
pet3 = Pet(name='Ocelot', available=False)
db.session.add_all([person, pet1, pet2, pet3])
db.session.commit()
# Start app
app.run(debug=True, port=5001)
def init_app(app):
admin.name = app.config.TITLE
admin.template_mode = "bootstrap3"
admin.init_app(app)
admin.add_view(sqla.ModelView(Product, db.session))
admin.add_view(UserAdmin(User, db.session))
app.config[
'SQLALCHEMY_DATABASE_URI'] = 'sqlite:///' + app.config['DATABASE_FILE']
app.config['SQLALCHEMY_ECHO'] = True
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True
db = SQLAlchemy(app)
class Server(db.Model):
id = db.Column(db.Integer, primary_key=True)
ip = db.Column(db.String(15), index=True, unique=True)
desc = db.Column(db.String(120))
state = db.Column(db.Boolean, default=True, nullable=False)
@app.route('/')
def index():
return '<a href="/admin/">Click me to get to Admin!</a>'
admin = admin.Admin(app, name='Manager', template_mode='bootstrap3')
admin.add_view(sqla.ModelView(Server, db.session))
if __name__ == '__main__':
app_dir = op.realpath(os.path.dirname(__file__))
database_path = op.join(app_dir, app.config['DATABASE_FILE'])
if not os.path.exists(database_path):
db.create_all()
app.run(debug=True)
from flask_sqlalchemy import SQLAlchemy
import flask_admin as admin
from flask_admin.contrib import sqla
from models import Base, Device
app = Flask(__name__)
# SET YOUR CONFIG
app.config['SECRET_KEY'] = '123456790'
app.config['DATABASE_FILE'] = 'tippy.sqlite'
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///' + app.config['DATABASE_FILE']
app.config['SQLALCHEMY_ECHO'] = True
db = SQLAlchemy(app)
admin = admin.Admin(app, name='Tippy', url='/', template_mode='bootstrap3')
admin.add_view(sqla.ModelView(Device, db.session))
def build_db():
Base.metadata.drop_all(bind=db.engine)
Base.metadata.create_all(bind=db.engine)
if __name__ == "__main__":
app_dir = op.realpath(os.path.dirname(__file__))
database_path = op.join(app_dir, app.config['DATABASE_FILE'])
if not os.path.exists(database_path):
build_db()
app.run()
<p><a href="/admin/?lang=es">Click me to get to Admin! (Spanish)</a></p>
<p><a href="/admin/?lang=fa">Click me to get to Admin! (Farsi)</a></p>
<p><a href="/admin/?lang=fr">Click me to get to Admin! (French)</a></p>
<p><a href="/admin/?lang=pt">Click me to get to Admin! (Portuguese)</a></p>
<p><a href="/admin/?lang=ru">Click me to get to Admin! (Russian)</a></p>
<p><a href="/admin/?lang=pa">Click me to get to Admin! (Punjabi)</a></p>
<p><a href="/admin/?lang=zh_CN">Click me to get to Admin! (Chinese - Simplified)</a></p>
<p><a href="/admin/?lang=zh_TW">Click me to get to Admin! (Chinese - Traditional)</a></p>
"""
return tmp
@app.route("/favicon.ico")
def favicon():
return send_file("static/favicon.ico")
# Create admin
admin = admin.Admin(app,
name="Example: SQLAlchemy",
template_mode="bootstrap4")
# Add views
admin.add_view(sqla.ModelView(Product, db.session))
admin.add_view(sqla.ModelView(ProductProxyCastToInt, db.session))
admin.add_view(sqla.ModelView(ProductProxyCastToFloat, db.session))
admin.add_view(sqla.ModelView(ProductProxyCastToDecimal, db.session))
admin.add_view(sqla.ModelView(ProductProxyLimitChoicesTo, db.session))
admin.add_view(sqla.ModelView(ProductProxyChoicesFuncNone, db.session))
admin.add_view(sqla.ModelView(ProductProxyAmountFieldsIsNone, db.session))
def create_app():
app = Flask(__name__)
app.config["SQLALCHEMY_DATABASE_URI"] = 'sqlite:///flask-admin.db'
register_extensions(app)
register_jinja_funcs(app)
# Create modules
app.register_blueprint(indexModule)
app.register_blueprint(manageModule)
app.register_blueprint(attributeModule)
app.register_blueprint(profileModule)
app.register_blueprint(recommentationModule)
app.register_blueprint(overviewModule)
app.register_blueprint(influenceModule)
app.register_blueprint(loginModule)
app.register_blueprint(groupModule)
app.register_blueprint(detectModule)
app.register_blueprint(tagModule)
app.register_blueprint(ucenterModule)
# app.register_blueprint(weiboModule)
app.register_blueprint(sensingModule)
app.register_blueprint(sentimentModule)
app.register_blueprint(networkModule)
app.register_blueprint(userrankModule)
# the debug toolbar is only enabled in debug mode
app.config['DEBUG'] = True
app.config['ADMINS'] = frozenset(['*****@*****.**'])
app.config['SECRET_KEY'] = 'SecretKeyForSessionSigning'
'''
app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql+mysqldb://%s:@%s/%s?charset=utf8' % (MYSQL_USER, MYSQL_HOST, MYSQL_DB)
app.config['SQLALCHEMY_ECHO'] = False
'''
app.config['DATABASE_CONNECT_OPTIONS'] = {}
app.config['THREADS_PER_PAGE'] = 8
app.config['CSRF_ENABLED'] = True
app.config['CSRF_SESSION_KEY'] = 'somethingimpossibletoguess'
# Enable the toolbar?
app.config['DEBUG_TB_ENABLED'] = app.debug
# Should intercept redirects?
app.config['DEBUG_TB_INTERCEPT_REDIRECTS'] = True
# Enable the profiler on all requests, default to false
app.config['DEBUG_TB_PROFILER_ENABLED'] = True
# Enable the template editor, default to false
app.config['DEBUG_TB_TEMPLATE_EDITOR_ENABLED'] = True
# debug toolbar
# toolbar = DebugToolbarExtension(app)
# init database
db.init_app(app)
with app.test_request_context():
db.create_all()
# init security
security.init_app(app, datastore=user_datastore)
# init admin
admin.init_app(app)
admin.add_view(sqla.ModelView(User, db.session))
admin.add_view(sqla.ModelView(Role, db.session))
'''
app.config['MONGO_HOST'] = MONGODB_HOST
app.config['MONGO_PORT'] = MONGODB_PORT
app.config['MONGODB_SETTINGS'] = {
'db': MASTER_TIMELINE_54API_WEIBO_DB,
'host': MONGODB_HOST,
'port': MONGODB_PORT
}
# Create mysql database
db.init_app(app)
with app.test_request_context():
db.create_all()
# Create mongo_engine
mongo_engine.init_app(app)
admin.init_app(app)
"""
# Create mysql database admin, visit via url: http://HOST:PORT/admin/
for m in model.__all__:
m = getattr(model, m)
n = m._name()
admin.add_view(SQLModelView(m, db.session, name=n))
for m in mongodb_model.__all__:
admin.add_view(MongoDBView(m))
"""
# init mongo
mongo.init_app(app)
'''
return app
def init_app(app):
admin.name = app.config.TITLE
admin.template_mode = 'bootstrap3'
admin.init_app(app)
# iniciando admin
admin.add_view(sqla.ModelView(Products, db.session))
def __init__(self, name, price, category_id):
self.name = name
self.price = price
self.category_id = category_id
def __repr__(self):
return '<Product %d>' % self.id
@app.route('/pcr', methods=['GET', 'POST'])
def create_product():
if request.method == 'POST':
name = request.form.get('name')
price = request.form.get('price')
category_id = request.form.get('category')
product = Product(name, price, category_id)
db.session.add(product)
db.session.commit()
flash('The product %s has been created' % name, 'success')
return redirect(url_for('create_product', id=product.id))
return render_template('product-create.html')
# Create admin
admin = admin.Admin(app, name='simple create form', template_mode='bootstrap3')
admin.add_view(sqla.ModelView(Product, db.session))
if __name__ == '__main__':
db.create_all()
app.run(debug=True)
description: Review description
'''
__tablename__ = 'Reviews'
reader_id = db.Column(db.String, db.ForeignKey('People.id'), primary_key=True)
book_id = db.Column(db.String, db.ForeignKey('Books.id'), primary_key=True)
review = db.Column(db.String, default = '')
person = db.relationship(Person)
book = db.relationship(Book)
db.create_all()
#
# Flask-Admin Config
#
admin = Admin(app, url='/admin')
admin.add_view(sqla.ModelView(Person, db.session))
admin.add_view(sqla.ModelView(Book, db.session))
admin.add_view(sqla.ModelView(Review, db.session))
admin.add_view(sqla.ModelView(Publisher, db.session))
#
# jsonapi-admin config
#
@app.route('/ja')
def redir_ja():
return redirect('/ja/index.html')
@app.route('/ja/<path:path>', endpoint="jsonapi_admin")
def send_ja(path):
return send_from_directory('/home/thomaxxl/mysite/jsonapi-admin/build', path)
class RecipeAdmin(sqla.ModelView):
column_list = ('recipe', 'method')
column_editable_list = column_list
class RecipeArgAdmin(sqla.ModelView):
column_list = ('recipe', 'methodarg', 'strvalue')
column_editable_list = column_list
# Create admin app
admin = Admin(app, name="Constrain Values", template_mode='bootstrap3')
admin.add_view(RecipeArgAdmin(RecipeArg, db.session))
# More submenu
admin.add_view(sqla.ModelView(Method, db.session, category='See Other Tables'))
admin.add_view(
MethodArgAdmin(MethodArg, db.session, category='See Other Tables'))
admin.add_view(RecipeAdmin(Recipe, db.session, category='See Other Tables'))
if __name__ == '__main__':
db.drop_all()
db.create_all()
db.session.add(Method(mid=1, method='tabulate_results'))
db.session.add(Method(mid=2, method='pretty_print'))
db.session.commit()
db.session.add(MethodArg(maid=1, mid=1, methodarg='rows'))
db.session.add(MethodArg(maid=2, mid=1, methodarg='display_total'))
db.session.add(
MethodArg(maid=3, mid=2, methodarg='embellishment_character'))
<p><a href="/admin/?lang=en">Click me to get to Admin! (English)</a></p>
<p><a href="/admin/?lang=cs">Click me to get to Admin! (Czech)</a></p>
<p><a href="/admin/?lang=de">Click me to get to Admin! (German)</a></p>
<p><a href="/admin/?lang=es">Click me to get to Admin! (Spanish)</a></p>
<p><a href="/admin/?lang=fa">Click me to get to Admin! (Farsi)</a></p>
<p><a href="/admin/?lang=fr">Click me to get to Admin! (French)</a></p>
<p><a href="/admin/?lang=pt">Click me to get to Admin! (Portuguese)</a></p>
<p><a href="/admin/?lang=ru">Click me to get to Admin! (Russian)</a></p>
<p><a href="/admin/?lang=pa">Click me to get to Admin! (Punjabi)</a></p>
<p><a href="/admin/?lang=zh_CN">Click me to get to Admin! (Chinese - Simplified)</a></p>
<p><a href="/admin/?lang=zh_TW">Click me to get to Admin! (Chinese - Traditional)</a></p>
"""
return tmp
if __name__ == '__main__':
# Create admin
admin = admin.Admin(app, 'Example: Babel')
# admin.locale_selector(get_locale)
# Add views
admin.add_view(sqla.ModelView(User, db.session))
admin.add_view(sqla.ModelView(Post, db.session))
# Create DB
db.create_all()
# Start app
app.run(debug=True)
class ScreenView(sqla.ModelView):
column_list = ['id', 'width', 'height', 'number_of_pixels'] # not that 'number_of_pixels' is a hybrid property, not a field
column_sortable_list = ['id', 'width', 'height', 'number_of_pixels']
# Flask-admin can automatically detect the relevant filters for hybrid properties.
column_filters = ('number_of_pixels', )
# Create admin
admin = admin.Admin(app, name='Example: SQLAlchemy', template_mode='bootstrap3')
# Add views
admin.add_view(UserAdmin(User, db.session))
admin.add_view(sqla.ModelView(Tag, db.session))
admin.add_view(PostAdmin(db.session))
admin.add_view(sqla.ModelView(Pet, db.session, category="Other"))
admin.add_view(sqla.ModelView(UserInfo, db.session, category="Other"))
admin.add_view(TreeView(Tree, db.session, category="Other"))
admin.add_view(ScreenView(Screen, db.session, category="Other"))
admin.add_sub_category(name="Links", parent_name="Other")
admin.add_link(MenuLink(name='Back Home', url='/', category='Links'))
admin.add_link(MenuLink(name='Google', url='http://www.google.com/', category='Links'))
admin.add_link(MenuLink(name='Mozilla', url='http://mozilla.org/', category='Links'))
def build_sample_db():
"""
Populate a small db with some example entries.
"""
]
def is_accessible(self):
try :
return current_user.is_admin
except :
False
class IndexAdmin(admin.AdminIndexView) :
@expose('/')
def index(self):
if request.method == "GET" :
if not current_user.is_authenticated :
return redirect(url_for('index'))
elif current_user.is_anonymous :
return redirect(url_for('index'))
elif current_user.is_admin :
return self.render('index.html')
else :
return redirect(url_for('index'))
admin = admin.Admin(app,index_view=IndexAdmin(), name ='WhyDoThat Admin page', template_mode='bootstrap4')
admin.add_view(UserAdmin(User,db.session))
admin.add_view(JobDetailAdmin(JobDetail,db.session))
admin.add_view(CompanyInfoAdmin(CompanyInfo,db.session))
admin.add_view(sqla.ModelView(JobSector,db.session))
admin.add_view(sqla.ModelView(JobSkill,db.session))
admin.add_view(sqla.ModelView(Resume,db.session,category='Other'))
admin.add_sub_category(name="Links", parent_name="Other")
admin.add_link(MenuLink(name='Back Home', url='/', category='Links'))
admin.add_link(MenuLink(name='Logout', url='/api/logout', category='Links'))
def __init__(self, session):
# Just call parent class with predefined model.
super(PostAdmin, self).__init__(Post, session)
class TreeView(sqla.ModelView):
form_excluded_columns = ['children', ]
# Create admin
admin = admin.Admin(app, name='Example: SQLAlchemy', template_mode='bootstrap3')
# Add views
admin.add_view(UserAdmin(User, db.session))
admin.add_view(sqla.ModelView(Tag, db.session))
admin.add_view(PostAdmin(db.session))
admin.add_view(TreeView(Tree, db.session))
def build_sample_db():
"""
Populate a small db with some example entries.
"""
import random
import datetime
db.drop_all()
db.create_all()
def __init__(self,
config=None,
db=None,
name: str = None,
webconfig=None,
apiconfig=None,
overlay: dict = {}):
"""Erzeugt die Flask App.
ruft _create_app auf um die Datenbank Api bereitzustellen.
Parameters
----------
config : ispConfig
geladene config mit server.webserver und server.api
db: SQLAlchemy
Initialisiertes SQLAlchemy Object - db=SQLAlchemy()
name: str
Name der connection aus config.database.<name>.connection
webconfig : dot|dict
überschreibt ggf. die Inhalte aus config.server.webserver
apiconfig : dot|dict
überschreibt ggf. die Inhalte aus config.server.api
overlay : dict
überschreibt die Inhalte der config z.B. für unittest
Verwenden von Overlay::
from flask import current_app
print( current_app._configOverlay )
Returns
-------
None.
"""
if config == None:
config = ispConfig(
config={
"server": {
"webserver": {
"TESTING": True,
"SECRET_KEY": os.urandom(16)
}
}
})
elif not isinstance(config, ispConfig):
# config immer als ispConfig, dies lädt keine config daten sondern verwendet die angegebenen
config = ispConfig(config=config)
# overlay merken und config updaten
self._configOverlay = overlay
config.update(overlay)
# in self._config merken
self._config = config
# keys für contentparameter
self._urlContentParamsKey = '_ispcp'
self._headerContentParamsKey = 'X-ISP-CONTENT-PARAMS'
# default status code für templates (routeIndex)
self.status_code = 200
# default status code für templates (routeIndex)
self.default_header = {'Content-Type': 'text/html; charset=utf-8'}
#
# webserver konfiguration aus config.server erweitern
#
if webconfig:
self._config.merge("server.webserver", webconfig)
#
# api konfiguration aus config.server erweitern
#
if apiconfig:
self._config.merge("server.api", apiconfig)
#
# Hauptdatenbank festlegen
#
db_names = []
db_binds = {}
# name für die Main Datenbank
if not name:
name = self._config.get("database.main", [])
if type(name) == str:
db_names.append(name)
elif type(name) == list:
db_names = name
for name in db_names:
# versuchen eine passende datenbank config zu finden, wenn ja diese verwenden
#db_uri = self._config.get("database." + name + ".connection", "").format( **{"BASE_DIR": self._config.BASE_DIR } )
db_binds[name] = self._config.get("database." + name +
".connection",
"",
replaceVariables=True)
#
# App erzeugen mit SQLAlchemy() und DatabaseUri
#
app = self._create_app(db, db_binds)
# logger für safrs
log.setLevel(self._config.get("server.logging.safrs",
logging.WARNING)) # logging.DEBUG
# logger für sqlalchemy
sql_logger = logging.getLogger("sqlalchemy")
sql_logger.setLevel(
self._config.get("server.logging.sqlalchemy", logging.WARNING))
# app starten
if app:
# template_folder auf ui setzen wird bei routeRender verwendet
app.template_folder = osp.join(self._config.BASE_DIR, "ui")
# wenn gewünscht dbadmin interface bereitstellen
#
# wird in der klasse no_flask_admin=True angegeben wird für diese admin Interface eingebunden
if self._config.get("server.api.DBADMIN", False):
# see if we can add the flask-admin views
try:
from flask_admin import Admin
from flask_admin.contrib import sqla
except Exception as exc: # pragma: no cover
print(f"flask-admin import failed {exc}")
models = self._config.get("server.api.models", [])
try:
admin = Admin(app, url="/dbadmin")
for model in models:
if hasattr(model, "no_flask_admin"
) and model.no_flask_admin == True:
pass
else:
admin.add_view(sqla.ModelView(model, db.session))
except Exception as exc: # pragma: no cover
print(f"Failed to add flask-admin view {exc}")
# app.logger für flask
app.logger.setLevel(
self._config.get("server.logging.webapp", logging.WARNING))
# Modus festlegen
mode = "APP"
if self._config.get("server.webserver.TESTING"):
mode = "TESTING"
self.apiurl = "http://{}:{}{}".format(
self._config.get("server.webserver.host"),
self._config.get("server.webserver.port"),
self._config.get("server.api.prefix", ""))
# Webserver startparameter anzeigen
print("Starting '{}' in '{}' Mode".format(self.apiurl, mode))
#return
if mode == "TESTING":
# im testing mode starten
self.app = self.app.test_client()
else: # pragma: no cover
# add CORS support
# Content-Range wird von dstore ausgewertet um die max Anzahl zu bestimmen
CORS(
self.app,
expose_headers=
'Content-Range, Content-Newitem, X-Query, X-Rquery, X_Error, X_Info'
)
# dieser abschnitt wird bei coverage nicht berücksichtigt, da er im testmode nicht ausgeführt wird
# nach dem starten der app wird folgender code erst nach dem beenden ausgeführt
app.run(
host=self._config.get("server.webserver.host"),
port=self._config.get("server.webserver.port"),
use_reloader=self._config.get("server.webserver.reloader"),
threaded=False,
debug=self._config.get("server.webserver.debug"))
class UserAdmin(sqla.ModelView):
form_excluded_columns = ['messages']
class TalkMessage(sqla.ModelView):
inline_models = (Message, )
# Create admin
admin = admin.Admin(app, name='Corba Chat', template_mode='bootstrap3')
# Add views
admin.add_view(UserAdmin(User, db.session))
admin.add_view(TalkMessage(Talk, db.session))
admin.add_view(sqla.ModelView(Message, db.session))
#API
from src.server.api import rest
from src.server.api import corba
if __name__ == '__main__':
# Build a sample db on the fly, if one does not exist yet.
app_dir = op.realpath(os.path.dirname(__file__))
database_path = op.join(app_dir, app.config['DATABASE_FILE'])
if not os.path.exists(database_path):
db.drop_all()
db.create_all()
db.session.commit()
# Start app
app_run = app.run
# Create Flask application
app = Flask(__name__)
app.config.from_envvar('HISTCOMPARE_CONFIG')
# Loads data base
db = SQLAlchemy(app)
import utils
import db_models
from views import AdminIndexView, compare
admin = admin.Admin(app,
'Anomaly Detection',
index_view=AdminIndexView(),
base_template='my_master.html')
# Add view
app.view_functions['compare'] = compare
app.add_url_rule('/compare', 'compare', compare)
admin.add_view(sqla.ModelView(db_models.Request, db.session))
admin.add_view(sqla.ModelView(db_models.Histogram, db.session))
admin.add_view(sqla.ModelView(db_models.File, db.session))
if __name__ == '__main__':
# Build a sample db on the fly, if one does not exist yet.
app_dir = os.path.realpath(os.path.dirname(__file__))
database_path = os.path.join(app_dir, app.config['DATABASE_FILE'])
if not os.path.exists(database_path):
utils.build_sample_db()
# Start app
app.run(debug=True, host='0.0.0.0')
