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)