def __init__(self,
app,
url_prefix="/admin",
title="flask-dashed",
main_dashboard=None,
endpoint='admin'):
if not main_dashboard:
from .dashboard import DefaultDashboard
main_dashboard = DefaultDashboard
self.blueprint = Blueprint(endpoint,
__name__,
static_folder='static',
template_folder='templates')
self.app = app
self.url_prefix = url_prefix
self.endpoint = endpoint
self.title = title
self.secure_functions = OrderedMultiDict()
# Checks security for current path
self.blueprint.before_request(
lambda: self.check_path_security(request.path))
self.app.register_blueprint(self.blueprint, url_prefix=url_prefix)
self.root_nodes = []
self._add_node(main_dashboard, '/', 'main-dashboard', 'dashboard')
# Registers recursive_getattr filter
self.app.jinja_env.filters['recursive_getattr'] = recursive_getattr
def test_ordered_multidict_encoding():
""""Make sure URLs are properly encoded from OrderedMultiDicts"""
d = OrderedMultiDict()
d.add('foo', 1)
d.add('foo', 2)
d.add('foo', 3)
d.add('bar', 0)
d.add('foo', 4)
assert url_encode(d) == 'foo=1&foo=2&foo=3&bar=0&foo=4'
def __new__(cls, *args, **kwargs):
if not cls.model:
raise Exception('ModelAdminModule must provide `model` attribute')
if not cls.list_fields:
cls.list_fields = OrderedMultiDict()
for column in cls.model.__table__._columns:
cls.list_fields[column.name] = {
'label': column.name,
'column': getattr(cls.model, column.name)
}
if not cls.form_class:
cls.form_class = model_form(cls.model, cls.db_session)
return super(ModelAdminModule, cls).__new__(cls, *args, **kwargs)
class UserModule(ModelAdminModule):
model = User
db_session = db_session
profile_alias = aliased(Profile)
list_fields = OrderedMultiDict((
('id', {
'label': 'id',
'column': User.id
}),
('username', {
'label': 'username',
'column': User.username
}),
('profile.name', {
'label': 'name',
'column': profile_alias.name
}),
('profile.location', {
'label': 'location',
'column': profile_alias.location
}),
))
list_title = 'user list'
searchable_fields = ['username', 'profile.name', 'profile.location']
order_by = ('id', 'desc')
list_query_factory = model.query\
.outerjoin(profile_alias, 'profile')\
.options(contains_eager('profile', alias=profile_alias))\
form_class = UserForm
def create_object(self):
user = self.model()
user.profile = Profile()
return user
class BookModule(ModelAdminModule):
"""Sample module with explicit eager loaded query.
"""
model = Book
db_session = db.session
author_alias = aliased(Author)
list_fields = OrderedMultiDict((
('id', {
'label': 'id',
'column': Book.id
}),
('title', {
'label': 'book title',
'column': Book.title
}),
('year', {
'label': 'year',
'column': Book.year
}),
('author.name', {
'label': 'author name',
'column': author_alias.name
}),
))
list_title = 'books list'
searchable_fields = ['title', 'author.name']
order_by = ('id', 'asc')
list_query_factory = model.query\
.outerjoin(author_alias, 'author')\
.options(contains_eager('author', alias=author_alias))\
form_class = BookForm
def custom_form_factory(form, field_types=None, field_slugs=None,
excluded_field_types=None,
registration_fields=False):
fields = (CustomField.query.filter_by(meeting_id=g.meeting.id)
.order_by(CustomField.sort))
if field_types:
fields = fields.filter(CustomField.field_type.in_(field_types))
if field_slugs:
fields = fields.filter(CustomField.slug.in_(field_slugs))
if excluded_field_types:
fields = fields.filter(
~CustomField.field_type.in_(excluded_field_types))
if registration_fields:
fields = fields.for_registration()
if getattr(form, 'CUSTOM_FIELDS_TYPE', None):
fields = fields.filter_by(custom_field_type=form.CUSTOM_FIELDS_TYPE)
form_attrs = {
'_custom_fields': OrderedMultiDict({c.slug: c for c in fields}),
}
for f in fields:
attrs = {'label': unicode(CustomFieldLabel(f.label)),
'validators': [],
'render_kw': {},
'description': f.hint}
data = _CUSTOM_FIELDS_MAP[f.field_type.code]
# overwrite data if _CUSTOM_FIELDS_MAP attribute is present on form
form_fields_map = getattr(form, '_CUSTOM_FIELDS_MAP', None)
if form_fields_map:
try:
data = form_fields_map[f.field_type.code]
except KeyError:
pass
if f.required:
attrs['validators'].append(DataRequired())
attrs['validators'].extend(data.get('validators', []))
if f.max_length:
attrs['validators'].append(Length(max=f.max_length))
if f.field_type.code == CustomField.SELECT:
query = CustomFieldChoice.query.filter_by(custom_field=f)
attrs['choices'] = [(unicode(c.value), __(c.value.english))
for c in query]
if not f.required:
attrs['choices'] = [('', '---')] + attrs['choices']
if f.slug == 'title':
attrs['choices'] = [choice for choice in attrs['choices']
if choice[0] in app.config['TITLE_CHOICES']]
attrs['coerce'] = unicode
if f.field_type.code == CustomField.LANGUAGE:
attrs['choices'] = [i for i in Participant.LANGUAGE_CHOICES
if i[0].lower() in app.config['TRANSLATIONS']]
if not f.required:
attrs['choices'] = [('', '---')] + attrs['choices']
attrs['coerce'] = unicode
if f.field_type.code == CustomField.CATEGORY:
query = Category.get_categories_for_meeting(
form.CUSTOM_FIELDS_TYPE)
if registration_fields:
query = query.filter_by(visible_on_registration_form=True)
attrs['choices'] = [(c.id, c) for c in query]
attrs['coerce'] = int
if f.field_type.code in (CustomField.MULTI_CHECKBOX, CustomField.RADIO):
query = CustomFieldChoice.query.filter_by(custom_field=f)
attrs['choices'] = [(unicode(c.value), c.value) for c in query]
attrs['coerce'] = unicode
if f.field_type.code == CustomField.IMAGE and f.photo_size and f.photo_size.code:
attrs['render_kw']["data-photoSize"] = f.photo_size.code
for coord in ("x1", "y1", "x2", "y2"):
form_attrs['%s_%s_' % (f.slug, coord)] = HiddenField(default=0)
# set field to form
# _set_rules_for_custom_fields(f, attrs)
field = data['field'](**attrs)
setattr(field, 'field_type', f.field_type.code)
form_attrs[f.slug] = field
form_attrs['rules'] = Rule.get_rules_for_fields(fields)
return type(form)(form.__name__, (form,), form_attrs)
def __init__(self, *args, **kwargs):
super(AdminModule, self).__init__(*args, **kwargs)
self.rules = OrderedMultiDict()
self._register_rules()
