Skip to content
Snippets Groups Projects
Commit afe0abd1 authored by Gallenkamp, Fabian's avatar Gallenkamp, Fabian
Browse files

Initial commit

parents
No related branches found
No related tags found
No related merge requests found
# Byte-compiled / optimized / DLL files
__pycache__/
*.py[cod]
*$py.class
# C extensions
*.so
# Distribution / packaging
.Python
env/
build/
develop-eggs/
dist/
downloads/
eggs/
.eggs/
lib/
lib64/
parts/
sdist/
var/
data/
*.egg-info/
.installed.cfg
*.egg
# PyInstaller
# Usually these files are written by a python script from a template
# before PyInstaller builds the exe, so as to inject date/other infos into it.
*.manifest
*.spec
# Installer logs
pip-log.txt
pip-delete-this-directory.txt
# Unit test / coverage reports
htmlcov/
.tox/
.coverage
.coverage.*
.cache
nosetests.xml
coverage.xml
*,cover
.hypothesis/
# Translations
*.mo
*.pot
# Django stuff:
*.log
local_settings.py
# Flask stuff:
instance/
.webassets-cache
# Scrapy stuff:
.scrapy
# Sphinx documentation
docs/_build/
# PyBuilder
target/
# IPython Notebook
.ipynb_checkpoints
# pyenv
.python-version
# celery beat schedule file
celerybeat-schedule
# dotenv
.env
# virtualenv
venv/
ENV/
# Spyder project settings
.spyderproject
# Rope project settings
.ropeproject
# Intellig
.idea/
# DB-Connection
inventory/config.py
\ No newline at end of file
SQLAlchemy model backend integration examples.
To run this example:
1. Clone the repository::
git clone https://github.com/flask-admin/flask-admin.git
cd flask-admin
2. Create and activate a virtual environment::
virtualenv env
source env/bin/activate
3. Install requirements::
pip install -r 'examples/sqla/requirements.txt'
4. Run the application::
python examples/sqla/app.py
The first time you run this example, a sample sqlite database gets populated automatically. To suppress this behaviour,
comment the following lines in app.py:::
if not os.path.exists(database_path):
build_sample_db()
app.py 0 → 100644
import os,sys
import os.path as op
import zipfile
import io
import pathlib
from flask import Flask, flash, send_file
from flask_sqlalchemy import SQLAlchemy
from jinja2 import Template
from sqlalchemy.ext.hybrid import hybrid_property
from wtforms import validators
import flask_admin as admin
from flask_admin.base import MenuLink
from flask_admin.contrib import sqla
from flask_admin.contrib.sqla import filters
from flask_admin.contrib.sqla.form import InlineModelConverter
from flask_admin.contrib.sqla.fields import InlineModelFormList
from flask_admin.contrib.sqla.filters import BaseSQLAFilter, FilterEqual
from flask_admin.actions import action
# Create application
app = Flask(__name__)
# set optional bootswatch theme
# see http://bootswatch.com/3/ for available swatches
app.config['FLASK_ADMIN_SWATCH'] = 'cerulean'
# Create dummy secrey key so we can use sessions
app.config['SECRET_KEY'] = '123456790'
# Create in-memory database
app.config['DATABASE_FILE'] = 'sample_db.sqlite'
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///' + app.config['DATABASE_FILE']
app.config['SQLALCHEMY_ECHO'] = True
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db = SQLAlchemy(app)
# Create M2M table
software_features_table = db.Table('software_features', db.Model.metadata,
db.Column('software_id', db.Integer, db.ForeignKey('software.id')),
db.Column('feature_id', db.Integer, db.ForeignKey('feature.id')))
# Create N2one table
software_licence_table = db.Table('software_license', db.Model.metadata,
db.Column('software_id', db.Integer, db.ForeignKey('software.id')),
db.Column('license_id', db.Integer, db.ForeignKey('license.id')))
class License(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100))
version = db.Column(db.String(100))
def __str__(self):
return "{}".format(self.name)if not self.version else "{}-{}".format(self.name, self.version)
def __repr__(self):
return "{}: {}".format(self.id, self.__str__())
class Feature(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Unicode(64))
def __str__(self):
return "{}".format(self.name)
class Matterofexpense(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Unicode(64))
def __str__(self):
return "{}".format(self.name)
class Software(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(120))
text = db.Column(db.Text, nullable=False)
date = db.Column(db.Date)
license_id = db.Column(db.Integer(), db.ForeignKey(License.id))
license = db.relationship(License, backref='softwares')
matterofexpense_id = db.Column(db.Integer(), db.ForeignKey(Matterofexpense.id))
matterofexpense = db.relationship(Matterofexpense, backref='softwares')
features = db.relationship('Feature', secondary=software_features_table)
def __str__(self):
return "{}".format(self.name)
# Flask views
@app.route('/')
def index():
return '<a href="/admin/">Click me to get to Admin!</a>'
# Custom filter class
class FilterLastNameBrown(BaseSQLAFilter):
def apply(self, query, value, alias=None):
if value == '1':
return query.filter(self.column == "Brown")
else:
return query.filter(self.column != "Brown")
def operation(self):
return 'is Brown'
'''
# Customized User model admin
inline_form_options = {
'form_label': "Info item",
'form_columns': ['id', 'key', 'value'],
'form_args': None,
'form_extra_fields': None,
}'''
class AdvancedExportView(sqla.ModelView):
@action('advancedexport', 'AdvancedExport')
def action_advancedexport(self, ids):
try:
with open('templates/export/software.jinja2', "r", encoding="utf-8") as file_:
template = Template(file_.read())
softwares = Software.query.filter(Software.id.in_(ids))
for software_tool in softwares:
template.stream(name=software_tool.name).dump('./data/' + software_tool.name + '.asciidoc', encoding='utf-8')
base_path = pathlib.Path('./data/')
data = io.BytesIO()
with zipfile.ZipFile(data, mode='w') as z:
for f_name in base_path.iterdir():
z.write(f_name)
data.seek(0)
return send_file(
data,
mimetype='application/zip',
as_attachment=True,
attachment_filename='data.zip'
)
flash("Done")
except Exception as ex:
if not self.handle_view_exception(ex):
raise
flash("Not done")
'''
class UserAdmin(sqla.ModelView):
action_disallowed_list = ['delete', ]
column_display_pk = True
column_list = [
'id',
'last_name',
'first_name',
'email',
'pets',
]
column_default_sort = [('last_name', False), ('first_name', False)] # sort on multiple columns
# custom filter: each filter in the list is a filter operation (equals, not equals, etc)
# filters with the same name will appear as operations under the same filter
column_filters = [
FilterEqual(column=User.last_name, name='Last Name'),
FilterLastNameBrown(column=User.last_name, name='Last Name',
options=(('1', 'Yes'), ('0', 'No')))
]
inline_models = [(UserInfo, inline_form_options), ]
# setup create & edit forms so that only 'available' pets can be selected
def create_form(self):
return self._use_filtered_parent(
super(UserAdmin, self).create_form()
)
def edit_form(self, obj):
return self._use_filtered_parent(
super(UserAdmin, self).edit_form(obj)
)
def _use_filtered_parent(self, form):
form.pets.query_factory = self._get_parent_list
return form
def _get_parent_list(self):
# only show available pets in the form
return Pet.query.filter_by(available=True).all()
'''
'''
# Customized Post model admin
class PostAdmin(sqla.ModelView):
column_list = ['id', 'user', 'title', 'date', 'tags']
column_default_sort = ('date', True)
column_sortable_list = [
'id',
'title',
'date',
('user', ('user.last_name', 'user.first_name')), # sort on multiple columns
]
column_labels = dict(title='Post Title') # Rename 'title' column in list view
column_searchable_list = [
'title',
'tags.name',
'user.first_name',
'user.last_name',
]
column_labels = {
'title': 'Title',
'tags.name': 'tags',
'user.first_name': 'user\'s first name',
'user.last_name': 'last name',
}
column_filters = [
'user',
'title',
'date',
'tags',
filters.FilterLike(Post.title, 'Fixed Title', options=(('test1', 'Test 1'), ('test2', 'Test 2'))),
]
can_export = True
export_max_rows = 1000
export_types = ['csv', 'xls']
# Pass arguments to WTForms. In this case, change label for text field to
# be 'Big Text' and add required() validator.
form_args = dict(
text=dict(label='Big Text', validators=[validators.data_required()])
)
form_ajax_refs = {
'user': {
'fields': (User.first_name, User.last_name)
},
'tags': {
'fields': (Tag.name,),
'minimum_input_length': 0, # show suggestions, even before any user input
'placeholder': 'Please select',
'page_size': 5,
},
}
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', ]
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(AdvancedExportView(Software, db.session))
admin.add_view(sqla.ModelView(Feature, db.session))
admin.add_view(sqla.ModelView(License, 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.
"""
import random
import datetime
db.drop_all()
db.create_all()
db.session.add(License(name="GPL", version="3.0"))
db.session.add(License(name="MIT"))
db.session.commit()
return
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):
build_sample_db()
# Start app
app.run(debug=True)
File added
{% extends 'admin/master.html' %}
{% block body %}
{{ super() }}
<div class="container">
<div class="row">
<div class="col-sm-10 col-sm-offset-1">
<h1>Flask-Admin example</h1>
<p class="lead">
Basic SQLAlchemy model views.
</p>
<p>
This example shows how to add basic CRUD-views for your SQLAlchemy models.
</p>
<p>
The views are generated automatically, but it is perfectly possible to customize them to suit your needs.
</p>
<a class="btn btn-primary" href="/"><i class="glyphicon glyphicon-chevron-left"></i> Back</a>
</div>
</div>
</div>
{% endblock body %}
.Basisdaten
|===
| Name | {{ name }}
| Entwickler | #developer
| Aktuelle Version | #version
| Letzte ÄÄnderung | #lastrelease
| Programmiersprache | #prog-language-list
| Betriebssystem | #os
| Lizenz | #license
| Sprache | #language
| Links | link:http://vanatteveldt.com/amcat/[Entwicklerseite]
|===
\ No newline at end of file
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment