def conv_List(self, model, field, kwargs):
if field.field is None:
raise ValueError(
'ListField "%s" must have field specified for model %s' %
(field.name, model))
if isinstance(field.field, ReferenceField):
kwargs['widget'] = form.Select2Widget(multiple=True)
doc_type = field.field.document_type
return mongo_fields.ModelSelectMultipleField(model=doc_type,
**kwargs)
# Create converter
view = self._get_subdocument_config(field.name)
converter = self.clone_converter(view)
if field.field.choices:
kwargs['multiple'] = True
return converter.convert(model, field.field, kwargs)
unbound_field = converter.convert(model, field.field, {})
kwargs = {
'validators': [],
'filters': [],
}
return InlineFieldList(unbound_field, min_entries=0, **kwargs)
def conv_List(self, model, field, kwargs):
if field.field is None:
raise ValueError(
'ListField "%s" must have field specified for model %s' %
(field.name, model))
if isinstance(field.field, ReferenceField):
loader = getattr(self.view, '_form_ajax_refs', {}).get(field.name)
if loader:
return AjaxSelectMultipleField(loader, **kwargs)
kwargs['widget'] = form.Select2Widget(multiple=True)
# TODO: Support AJAX multi-select
doc_type = field.field.document_type
return mongo_fields.ModelSelectMultipleField(model=doc_type,
**kwargs)
# Create converter
view = self._get_subdocument_config(field.name)
converter = self.clone_converter(view)
if field.field.choices:
kwargs['multiple'] = True
return converter.convert(model, field.field, kwargs)
unbound_field = converter.convert(model, field.field, {})
return InlineFieldList(unbound_field, min_entries=0, **kwargs)
def scaffold_form(self):
form_class = super(EventAdminView, self).scaffold_form()
form_class.roles = SelectMultipleField(
_('Roles with access'),
choices=forms._make_choices(
models.Role.objects(name__ne='admin').scalar('pk', 'name')),
widget=form.Select2Widget(multiple=True))
return form_class
def scaffold_form(self):
form_class = super(RoleAdminView, self).scaffold_form()
form_class.permissions = SelectMultipleField(
_('Permissions'),
choices=forms._make_choices(models.Need.objects().scalar(
'pk', 'action')),
widget=form.Select2Widget(multiple=True))
return form_class
def conv_Reference(self, model, field, kwargs):
kwargs['allow_blank'] = not field.required
loader = getattr(self.view, '_form_ajax_refs', {}).get(field.name)
if loader:
return AjaxSelectField(loader, **kwargs)
kwargs['widget'] = form.Select2Widget()
return orm.ModelConverter.conv_Reference(self, model, field, kwargs)
def _convert_relation(self, prop, kwargs):
remote_model = prop.mapper.class_
local_column = prop.local_remote_pairs[0][0]
kwargs['label'] = self._get_label(prop.key, kwargs)
kwargs['description'] = self._get_description(prop.key, kwargs)
if local_column.nullable:
kwargs['validators'].append(validators.Optional())
elif prop.direction.name != 'MANYTOMANY':
kwargs['validators'].append(validators.InputRequired())
# Contribute model-related parameters
if 'allow_blank' not in kwargs:
kwargs['allow_blank'] = local_column.nullable
if 'query_factory' not in kwargs:
kwargs['query_factory'] = lambda: self.session.query(remote_model)
if 'widget' not in kwargs:
if prop.direction.name == 'MANYTOONE':
kwargs['widget'] = form.Select2Widget()
elif prop.direction.name == 'ONETOMANY':
kwargs['widget'] = form.Select2Widget(multiple=True)
elif prop.direction.name == 'MANYTOMANY':
kwargs['widget'] = form.Select2Widget(multiple=True)
# Override field type if necessary
override = self._get_field_override(prop.key)
if override:
return override(**kwargs)
if prop.direction.name == 'MANYTOONE':
return QuerySelectField(**kwargs)
elif prop.direction.name == 'ONETOMANY':
# Skip backrefs
if not local_column.foreign_keys and getattr(self.view, 'column_hide_backrefs', True):
return None
return QuerySelectMultipleField(**kwargs)
elif prop.direction.name == 'MANYTOMANY':
return QuerySelectMultipleField(**kwargs)
def conv_Reference(self, model, field, kwargs):
kwargs['allow_blank'] = not field.required
loader = getattr(self.view, '_form_ajax_refs', {}).get(field.name)
if loader:
return AjaxSelectField(loader, **kwargs)
kwargs['widget'] = form.Select2Widget()
queryset = kwargs.get('queryset')
if callable(queryset):
kwargs['queryset'] = queryset(field.document_type)
return orm.ModelConverter.conv_Reference(self, model, field, kwargs)
class UserView(BaseAdminView):
column_exclude_list = ("created", "password_hash", "salt", "comment",
"private_group", "can_edit_shoppingbag",
"can_change_password")
column_filters = ("authenticator_info", "display_name", "login_name",
"organisation")
can_export = True
column_details_list = ("home_dir", "authenticator_info", "id",
"login_name", "display_name", "lastname",
"firstname", "telephone", "organisation", "comment",
"email", "password_hash", "salt", "last_login",
"active", "can_edit_shoppingbag",
"can_change_password", "created_at", "group_names")
"""
"""
column_labels = dict(group_names='Groups')
column_formatters = {
"home_dir":
lambda v, c, m, p: _link_format_node_id_column(m.home_dir.id)
if m.home_dir else None
}
column_searchable_list = ("display_name", "login_name", "organisation")
column_editable_list = ("login_name", "email")
form_excluded_columns = ("home_dir", "created", "password_hash", "salt",
"versions", "shoppingbags", "private_group",
"group_assocs")
form_overrides = {"email": StringField}
form_extra_fields = {
"groups":
QuerySelectMultipleField(
query_factory=lambda: db.query(UserGroup).order_by(UserGroup.name),
widget=form.Select2Widget(multiple=True)),
"password":
StringField()
}
def __init__(self, session=None, *args, **kwargs):
super(UserView, self).__init__(User,
session,
category="User",
*args,
**kwargs)
def on_model_change(self, form, user, is_created):
if form.password.data and user.authenticator_info.authenticator_key == INTERNAL_AUTHENTICATOR_KEY:
user.change_password(form.password.data)
def _model_select_field(self, prop, multiple, remote_model, **kwargs):
loader = getattr(self.view, '_form_ajax_refs', {}).get(prop.key)
if loader:
if multiple:
return AjaxSelectMultipleField(loader, **kwargs)
else:
return AjaxSelectField(loader, **kwargs)
if 'query_factory' not in kwargs:
kwargs['query_factory'] = lambda: self.session.query(remote_model)
if 'widget' not in kwargs:
if multiple:
kwargs['widget'] = form.Select2Widget(multiple=True)
else:
kwargs['widget'] = form.Select2Widget()
if multiple:
return QuerySelectMultipleField(**kwargs)
else:
return QuerySelectField(**kwargs)
def _model_select_field(self, prop, multiple, remote_model, **kwargs):
loader = self.view._form_ajax_refs.get(prop.key)
if loader:
if multiple:
return AjaxSelectMultipleField(loader, **kwargs)
else:
return AjaxSelectField(loader, **kwargs)
if 'query_factory' not in kwargs:
kwargs['query_factory'] = lambda: self.session.query(remote_model)
if 'widget' not in kwargs:
if prop.direction.name == 'MANYTOONE':
kwargs['widget'] = form.Select2Widget()
elif prop.direction.name == 'ONETOMANY':
kwargs['widget'] = form.Select2Widget(multiple=True)
elif prop.direction.name == 'MANYTOMANY':
kwargs['widget'] = form.Select2Widget(multiple=True)
if multiple:
return QuerySelectMultipleField(**kwargs)
else:
return QuerySelectField(**kwargs)
def conv_List(self, model, field, kwargs):
if isinstance(field.field, ReferenceField):
kwargs['widget'] = form.Select2Widget(multiple=True)
doc_type = field.field.document_type
return fields.ModelSelectMultipleField(model=doc_type, **kwargs)
if field.field.choices:
kwargs['multiple'] = True
return self.convert(model, field.field, kwargs)
unbound_field = self.convert(model, field.field, {})
kwargs = {
'validators': [],
'filters': [],
}
return InlineFieldList(unbound_field, min_entries=0, **kwargs)
def conv_xlist(self, model, field, kwargs):
if field.field is None:
raise ValueError(
'ListField "%s" must have field specified for model %s' %
(field.name, model))
if isinstance(field.field, ReferenceField):
loader = getattr(self.view, '_form_ajax_refs', {}).get(field.name)
if loader:
return AjaxSelectMultipleField(loader, **kwargs)
kwargs['widget'] = form.Select2Widget(multiple=True)
doc_type = field.field.document_type
return ModelSelectMultipleField(model=doc_type, **kwargs)
field.field.name = '%s__field' % field.name
if field.field.choices:
kwargs['multiple'] = True
return self.convert(model, field.field, kwargs)
unbound_field = self.convert(model, field.field, {})
return ListField(unbound_field, min_entries=0, **kwargs)
def conv_Reference(self, model, field, kwargs):
kwargs['widget'] = form.Select2Widget()
return orm.ModelConverter.conv_Reference(self, model, field, kwargs)
def convert(self, model, mapper, prop, field_args, hidden_pk):
kwargs = {'validators': [], 'filters': []}
if field_args:
kwargs.update(field_args)
# Check if it is relation or property
if hasattr(prop, 'direction'):
remote_model = prop.mapper.class_
local_column = prop.local_remote_pairs[0][0]
kwargs['label'] = self._get_label(prop.key, kwargs)
if local_column.nullable:
kwargs['validators'].append(validators.Optional())
elif prop.direction.name != 'MANYTOMANY':
kwargs['validators'].append(validators.Required())
# Override field type if necessary
override = self._get_field_override(prop.key)
if override:
return override(**kwargs)
# Contribute model-related parameters
if 'allow_blank' not in kwargs:
kwargs['allow_blank'] = local_column.nullable,
if 'query_factory' not in kwargs:
kwargs['query_factory'] = lambda: self.session.query(
remote_model)
if prop.direction.name == 'MANYTOONE':
return QuerySelectField(widget=form.Select2Widget(), **kwargs)
elif prop.direction.name == 'ONETOMANY':
# Skip backrefs
if not local_column.foreign_keys and getattr(
self.view, 'hide_backrefs', False):
return None
return QuerySelectMultipleField(
widget=form.Select2Widget(multiple=True), **kwargs)
elif prop.direction.name == 'MANYTOMANY':
return QuerySelectMultipleField(
widget=form.Select2Widget(multiple=True), **kwargs)
else:
# Ignore pk/fk
if hasattr(prop, 'columns'):
# Check if more than one column mapped to the property
if len(prop.columns) != 1:
raise TypeError(
'Can not convert multiple-column properties (%s.%s)' %
(model, prop.key))
# Grab column
column = prop.columns[0]
# Do not display foreign keys - use relations
if column.foreign_keys:
return None
unique = False
if column.primary_key:
if hidden_pk:
# If requested to add hidden field, show it
return fields.HiddenField()
else:
# By default, don't show primary keys either
form_columns = getattr(self.view, 'form_columns', None)
if form_columns is None:
return None
# If PK is not explicitly allowed, ignore it
if prop.key not in form_columns:
return None
kwargs['validators'].append(
Unique(self.session, model, column))
unique = True
# If field is unique, validate it
if column.unique and not unique:
kwargs['validators'].append(
Unique(self.session, model, column))
if not column.nullable and not isinstance(
column.type, Boolean):
kwargs['validators'].append(validators.Required())
# Apply label
kwargs['label'] = self._get_label(prop.key, kwargs)
# Figure out default value
default = getattr(column, 'default', None)
value = None
if default is not None:
value = getattr(default, 'arg', None)
if value is not None:
if getattr(default, 'is_callable', False):
value = value(None)
else:
if not getattr(default, 'is_scalar', True):
value = None
if value is not None:
kwargs['default'] = value
# Check nullable
if column.nullable:
kwargs['validators'].append(validators.Optional())
# Override field type if necessary
override = self._get_field_override(prop.key)
if override:
return override(**kwargs)
# Run converter
converter = self.get_converter(column)
if converter is None:
return None
return converter(model=model,
mapper=mapper,
prop=prop,
column=column,
field_args=kwargs)
return None
def convert(self, model, mapper, prop, field_args, hidden_pk, name):
kwargs = {'validators': [], 'filters': []}
if field_args:
kwargs.update(field_args)
# Check if it is relation or property
if hasattr(prop, 'direction') or hasattr(prop, 'scalar'):
if hasattr(prop, 'scalar'):
# property is an assoc proxy
proxy = prop
prop = proxy.target_class._sa_class_manager.mapper.get_property(
proxy.value_attr)
direction = prop.direction.name
if not proxy.scalar:
if direction in ('ONETOMANY', 'MANYTOONE'):
direction = 'MANYTOMANY'
elif direction == 'ONETOONE':
direction = 'MANYTOONE'
else:
direction = 'MANYTOMANYTOMANY' # we can't handle this,
# but maybe overridden
# widget can
else:
direction = prop.direction.name
remote_model = prop.mapper.class_
local_column = prop.local_remote_pairs[0][0]
kwargs['label'] = self._get_label(name, kwargs)
kwargs['description'] = self._get_description(name, kwargs)
if local_column.nullable:
kwargs['validators'].append(validators.Optional())
elif prop.direction.name != 'MANYTOMANY':
kwargs['validators'].append(validators.InputRequired())
# Override field type if necessary
override = self._get_field_override(name)
if override:
return override(**kwargs)
# Contribute model-related parameters
if 'allow_blank' not in kwargs:
kwargs['allow_blank'] = local_column.nullable
if 'query_factory' not in kwargs:
kwargs['query_factory'] = lambda: self.session.query(
remote_model)
if direction == 'MANYTOONE':
return QuerySelectField(widget=form.Select2Widget(), **kwargs)
elif direction == 'ONETOMANY':
# Skip backrefs
if not local_column.foreign_keys and getattr(
self.view, 'column_hide_backrefs', False):
return None
return QuerySelectMultipleField(
widget=form.Select2Widget(multiple=True), **kwargs)
elif direction == 'MANYTOMANY':
return QuerySelectMultipleField(
widget=form.Select2Widget(multiple=True), **kwargs)
else:
raise Exception('Unsupported relationship direction %s' %
direction)
else:
# Ignore pk/fk
if hasattr(prop, 'columns'):
# Check if more than one column mapped to the property
if len(prop.columns) != 1:
raise TypeError(
'Can not convert multiple-column properties (%s.%s)' %
(model, prop.key))
# Grab column
column = prop.columns[0]
# Do not display foreign keys - use relations
if column.foreign_keys:
return None
# Only display "real" columns
if not isinstance(column, Column):
return None
unique = False
if column.primary_key:
if hidden_pk:
# If requested to add hidden field, show it
return fields.HiddenField()
else:
# By default, don't show primary keys either
form_columns = getattr(self.view, 'form_columns', None)
if form_columns is None:
return None
# If PK is not explicitly allowed, ignore it
if prop.key not in form_columns:
return None
kwargs['validators'].append(
Unique(self.session, model, column))
unique = True
# If field is unique, validate it
if column.unique and not unique:
kwargs['validators'].append(
Unique(self.session, model, column))
if not column.nullable and not isinstance(
column.type, Boolean):
kwargs['validators'].append(validators.InputRequired())
# Apply label and description if it isn't inline form field
if self.view.model == mapper.class_:
kwargs['label'] = self._get_label(prop.key, kwargs)
kwargs['description'] = self._get_description(
prop.key, kwargs)
# Figure out default value
default = getattr(column, 'default', None)
value = None
if default is not None:
value = getattr(default, 'arg', None)
if value is not None:
if getattr(default, 'is_callable', False):
value = lambda: default.arg(None)
else:
if not getattr(default, 'is_scalar', True):
value = None
if value is not None:
kwargs['default'] = value
# Check nullable
if column.nullable:
kwargs['validators'].append(validators.Optional())
# Override field type if necessary
override = self._get_field_override(prop.key)
if override:
return override(**kwargs)
# Check choices
if mapper.class_ == self.view.model and self.view.form_choices:
choices = self.view.form_choices.get(column.key)
if choices:
return Select2Field(choices=choices,
allow_blank=column.nullable,
**kwargs)
# Run converter
converter = self.get_converter(column)
if converter is None:
return None
return converter(model=model,
mapper=mapper,
prop=prop,
column=column,
field_args=kwargs)
return None
def conv_Reference(self, model, field, kwargs):
kwargs['widget'] = form.Select2Widget()
kwargs['allow_blank'] = not field.required
return orm.ModelConverter.conv_Reference(self, model, field, kwargs)
class UserGroupView(BaseAdminView):
form_excluded_columns = "user_assocs"
column_details_list = [
"id", "name", "description", "hidden_edit_functions",
"is_editor_group", "is_workflow_editor_group", "is_admin_group",
"created_at", "metadatatype_access", "user_names"
]
column_searchable_list = ("name", "description")
column_filters = ("name", "description", "is_editor_group",
"is_workflow_editor_group", "is_admin_group")
can_export = True
column_labels = dict(metadatatype_access='Metadatatypes',
user_names='Users')
edit_functions = [
'acls', 'admin', 'changeschema', 'classes', 'editor', 'files',
'identifier', 'logo', 'metadata', 'search', 'searchmask', 'sortfiles',
'statsaccess', 'statsfiles', 'upload'
]
edit_function_choices = [(x, x) for x in edit_functions]
form_extra_fields = {
"users":
QuerySelectMultipleField(
query_factory=lambda: db.query(User).order_by(User.login_name),
widget=form.Select2Widget(multiple=True)),
"metadatatypes":
QuerySelectMultipleField(query_factory=lambda: db.query(Metadatatype).
order_by(Metadatatype.name),
widget=form.Select2Widget(multiple=True)),
"hidden_edit_functions":
SelectMultipleField(choices=edit_function_choices,
widget=form.Select2Widget(multiple=True)),
}
def on_form_prefill(self, form, id):
form.metadatatypes.data = form._obj.metadatatype_access
def on_model_change(self, form, usergroup, is_created):
if is_created:
""" create ruleset for group """
existing_ruleset = q(AccessRuleset).filter_by(
name=usergroup.name).scalar()
if existing_ruleset is None:
rule = get_or_add_access_rule(group_ids=[usergroup.id])
ruleset = AccessRuleset(name=usergroup.name,
description=usergroup.name)
arr = AccessRulesetToRule(rule=rule)
ruleset.rule_assocs.append(arr)
""" add/remove access to Metadatatypes """
for mt in q(Metadatatype):
nrs_list = q(NodeToAccessRuleset).filter_by(nid=mt.id).filter_by(
ruleset_name=usergroup.name).all()
if mt in form.metadatatypes.data:
if not nrs_list:
mt.access_ruleset_assocs.append(
NodeToAccessRuleset(ruleset_name=usergroup.name,
ruletype=u'read'))
else:
for nrs in nrs_list:
mt.access_ruleset_assocs.remove(nrs)
def __init__(self, session=None, *args, **kwargs):
super(UserGroupView, self).__init__(UserGroup,
session,
category="User",
*args,
**kwargs)
